¿Cómo llamar a un método en Java?

¿Cómo llamar a un método, que está en otra clase del mismo paquete en Java? Lo que sé es que al usar un objeto podemos llamar a un método de una clase diferente. ¿Hay alguna otra manera de llamar a un método de clase diferente?

Crea una instancia de Clase B:

B b=new B(); b.method(); 

o define un método estático en la Clase B:

 class B { static void staticMethod(); } 

y llámalo así:

 B.staticMethod(); 

Los métodos son métodos de objetos o métodos de clase .

Métodos de objeto: se aplica sobre un objeto. Tienes que usar una instancia:

 instance.method(args...); 

Métodos de clase: aplica sobre una clase. No tiene una instancia implícita. Tienes que usar la clase en sí. Es más como progtwigción de procedimientos.

 ClassWithStaticMethod.method(args...); 

Reflexión

Con la reflexión tiene una API para acceder mediante progtwigción a métodos, ya sean métodos de objeto o clase.

Métodos de instancia: methodRef.invoke(instance, args...); Métodos de clase: methodRef.invoke(null, args...);

Si define el método como estático, puede usarlo sin crear primero una instancia de la clase, pero tampoco tiene las variables de objeto disponibles para su uso.

 public class Foo { public static String Bar() { return "bla"; } } 

En ese caso, podría llamarlo con Foo.Bar() .

De las notas de Fred Swartz (fredosaurus) :

Hay dos tipos de métodos.

  • Los métodos de instancia están asociados con un objeto y usan las variables de instancia de ese objeto. Este es el predeterminado.

  • Los métodos estáticos no usan variables de instancia de ningún objeto de la clase en la que están definidos. Si define que un método es estático, el comstackdor le dará un mensaje grosero si intenta acceder a cualquier variable de instancia. Puede acceder a variables estáticas, pero a excepción de las constantes, esto es inusual. Los métodos estáticos típicamente toman todos los datos de los parámetros y calculan algo de esos parámetros, sin referencia a las variables. Esto es típico de los métodos que hacen algún tipo de cálculo genérico. Un buen ejemplo de esto son los muchos métodos de utilidad en la clase Math predefinida.

Calificando una llamada estática

Desde fuera de la clase de definición, se llama a un método de instancia prefijando un objeto, que luego se pasa como un parámetro implícito al método de instancia, por ejemplo, inputTF.setText("");

Se llama a un método estático Math.max(i,j); con un nombre de clase, por ejemplo, Math.max(i,j); . Curiosamente, también se puede calificar con un objeto, que se ignorará, pero se usará la clase del objeto.

Ejemplo

Aquí hay un método estático típico:

 class MyUtils { . . . //================================================= mean public static double mean(int[] p) { int sum = 0; // sum of all the elements for (int i=0; i 

Los únicos datos que este método usa o cambia son los parámetros (o variables locales, por supuesto).

Por qué declarar un método static

El método mean() anterior funcionaría igual de bien si no se declarase estático, siempre que se llamara desde dentro de la misma clase. Si se llama desde fuera de la clase y no se declaró estático, debería estar calificado (inútilmente) con un objeto. Incluso cuando se usa dentro de la clase, hay buenas razones para definir un método como estático cuando podría serlo.

  • Documentación. Cualquiera que vea que un método es estático sabrá cómo llamarlo (ver abajo). De forma similar, cualquier progtwigdor que observe el código sabrá que un método estático no puede interactuar con las variables de instancia, lo que facilita la lectura y la depuración.
  • Eficiencia. Un comstackdor generalmente producirá un código ligeramente más eficiente porque no se debe pasar ningún parámetro de objeto implícito al método.

Llamando a métodos estáticos

Hay dos casos

Llamado desde dentro de la misma clase

Simplemente escriba el nombre del método estático. P.ej:

 // Called from inside the MyUtils class double avgAtt = mean(attendance); 

Llamado desde fuera de la clase

Si se llama a un método (estático o instancia) desde otra clase, se debe dar algo antes del nombre del método para especificar la clase donde se define el método. Por ejemplo, métodos, este es el objeto al que accederá el método. Para los métodos estáticos, se debe especificar el nombre de la clase. P.ej:

 // Called from outside the MyUtils class. double avgAtt = MyUtils.mean(attendance); 

Si se especifica un objeto antes, se ignorará el valor del objeto y se usará la clase del objeto.

Accediendo a variables estáticas

Aunque un método static no puede acceder a variables de instancia, puede acceder a variables static . Un uso común de variables estáticas es definir "constantes". Los ejemplos de la biblioteca de Java son Math.PI o Color.RED . Están calificados con el nombre de clase, para que sepa que son static . Cualquier método, static o no, puede acceder a variables static . A las variables de instancia solo se puede acceder mediante métodos de instancia.

Llamada Alternativa

Lo que es un poco peculiar, y no recomendado, es que se puede usar un objeto de una clase en lugar del nombre de la clase para acceder a los métodos estáticos. Esto es malo porque crea la impresión de que se usan algunas variables de instancia en el objeto, pero este no es el caso.

Si se trata de un método estático, puede llamarlo utilizando el nombre de la clase en lugar de un objeto.

Puede crear un método estático o usar la otra clase como miembro de su clase llamando a la función en el constructor.

 public class aClass { private SomeOtherClass oc; public class aClass( SomeOtherClass otherClass) { oc = otherClass; } public callOtherClassMethod() { oc.otherClassMethod(); } } 

Hazlo en este formato:

classmehodisin.methodname();

Por ejemplo:

MyClass1.clearscreen();

Espero que esto haya ayudado. Nota: El método debe ser estático.

Al llamar al método

 public class a { void sum(int i,int k) { System.out.println("THe sum of the number="+(i+k)); } } class b { public static void main(String[] args) { a vc=new a(); vc.sum(10 , 20); } }