Java: Cómo acceder a métodos de otra clase

Traté de simplificar mi situación tanto como sea posible. Tengo tres clases:

Alfa:

public class Alpha { public void DoSomethingAlpha() { cbeta.DoSomethingBeta() //? } } 

Beta:

 public class Beta { public void DoSomethingBeta() { // Something } } 

Principal:

 public class MainApp { public static void main(String[] args) { Alpha cAlpha = new Alpha(); Beta cBeta = new Beta(); } } 

Espero no simplificarlo demasiado. Mi pregunta es ¿cómo puedo acceder a cBeta.DoSomethingBeta () desde un método en Alpha?

Necesitas de alguna manera darle a la clase Alpha una referencia a cBeta. Hay tres formas de hacer esto.

1) Dale a Alphas una Beta en el constructor. En clase Alpha escribe:

 public class Alpha { private Beta beta; public Alpha(Beta beta) { this.beta = beta; } 

y llame a cAlpha = nuevo Alpha (cBeta) desde main ()

2) darle a Alphas un mutador que les da una beta. En clase Alpha escribe:

 public class Alpha { private Beta beta; public void setBeta (Beta newBeta) { this.beta = beta; } 

y llame a cAlpha = new Alpha (); cAlpha.setBeta (beta); de main (), o

3) tener una beta como argumento para hacer AlgoAlfa. en clase Alpha escribe:

 public void DoSomethingAlpha(Beta cBeta) { cbeta.DoSomethingBeta() } 

La estrategia que utilices depende de algunas cosas. Si quieres que cada Alfa tenga una versión Beta, usa el número 1. Si solo quieres que algunos Alphas tengan una versión Beta, pero quieres que retengan sus Betas indefinidamente, usa el número 2. Si quieres que Alphas trate solo con Betas, Mientras llamas a doSomethingAlpha, usa el número 3. El scope de la variable es complicado al principio, pero se vuelve más fácil cuando le das la vuelta. ¡Avíseme si tiene más preguntas!

Método 1:

Si el método DoSomethingBeta es estático, solo necesita llamar:

 Beta.DoSomethingBeta(); 

Método 2:

Si Alpha se extiende desde Beta, puedes llamar a DoSomethingBeta () directamente.

 public class Alpha extends Beta{ public void DoSomethingAlpha() { DoSomethingBeta(); //? } } 

Método 3:

Alternativamente, debe tener acceso a una instancia de Beta para llamar a los métodos desde allí.

 public class Alpha { public void DoSomethingAlpha() { Beta cbeta = new Beta(); cbeta.DoSomethingBeta(); //? } } 

Por cierto es esta tarea?

Tal vez necesites alguna dependency injection

 public class Alpha { private Beta cbeta; public Alpha(Beta beta) { this.cbeta = beta; } public void DoSomethingAlpha() { this.cbeta.DoSomethingBeta(); } } 

y entonces

 Alpha cAlpha = new Alpha(new Beta()); 

O necesita crear un objeto de tipo Beta en la clase Alpha o su método

Como haces aquí en Main Beta cBeta = new Beta ();

Si quieres usar la variable que creas en tu Main, entonces debes analizarla como un parámetro haciendo que el constructor Alpha se vea como

 public class Alpha { Beta localInstance; public Alpha(Beta _beta) { localInstance = _beta; } public void DoSomethingAlpha() { localInstance.DoSomethingAlpha(); } } 
 public class WeatherResponse { private int cod; private String base; private Weather main; public int getCod(){ return this.cod; } public void setCod(int cod){ this.cod = cod; } public String getBase(){ return base; } public void setBase(String base){ this.base = base; } public Weather getWeather() { return main; } // default constructor, getters and setters } 

otra clase

 public class Weather { private int id; private String main; private String description; public String getMain(){ return main; } public void setMain(String main){ this.main = main; } public String getDescription(){ return description; } public void setDescription(String description){ this.description = description; } // default constructor, getters and setters } 

// accediendo a los métodos
// ¡éxito!

  Log.i("App", weatherResponse.getBase()); Log.i("App", weatherResponse.getWeather().getMain()); Log.i("App", weatherResponse.getWeather().getDescription()); 

Tengo otra solución. Si Alpha y Beta son su única clase extra, entonces ¿por qué no crear una variable estática con la imagen de la clase?

Al igual que en la clase Alpha:

 public class Alpha{ public static Alpha alpha; public Alpha(){ this.alpha = this; } 

Ahora puede llamar a la función en clase Beta con solo usar estas líneas:

 new Alpha(); Alpha.alpha.DoSomethingAlpha();