restricción - llamando al método no estático en el método estático en Java
public static java (14)
Esta pregunta ya tiene una respuesta aquí:
Me aparece un error cuando intento llamar a un método no estático en una clase estática.
No se puede hacer una referencia estática al método no estático methodName () del tipo playback
No puedo hacer que el método sea estático ya que esto también me da un error.
Este método estático no puede ocultar el método de instancia de xInterface
¿Hay alguna forma de evitar llamadas a un método no estático en otro método estático? (Los dos métodos están en paquetes separados y clases separadas).
Constructor es un método especial que en teoría es el "único" método no estático llamado por cualquier método estático. de lo contrario, no está permitido.
Hay dos maneras:
- Llame al método no estático desde una instancia dentro del método estático. Vea la respuesta de fabien para una muestra de un delineador de líneas ... aunque recomiendo encarecidamente que no lo haga. Con su ejemplo, crea una instancia de la clase y solo la usa para un método, solo para que se deshaga de ella más tarde. No lo recomiendo porque trata una instancia como una función estática.
- Cambia el método estático a no estático.
La única forma de llamar a un método no estático desde un método estático es tener una instancia de la clase que contenga el método no estático. Por definición, un método no estático es aquel que se llama ON en una instancia de alguna clase, mientras que un método estático pertenece a la clase misma.
La única forma de llamar a un método no estático desde un método estático es tener una instancia de la clase que contenga el método no estático.
class A
{
void method()
{
}
}
class Demo
{
static void method2()
{
A a=new A();
a.method();
}
/*
void method3()
{
A a=new A();
a.method();
}
*/
public static void main(String args[])
{
A a=new A();
/*an instance of the class is created to access non-static method from a static method */
a.method();
method2();
/*method3();it will show error non-static method can not be accessed from a static method*/
}
}
La forma más fácil de usar un método / campo no estático dentro de un método estático o viceversa es ...
(Para trabajar esto debe haber al menos una instancia de esta clase)
Este tipo de situación es muy común en el desarrollo de aplicaciones de Android, por ejemplo: - Una actividad tiene al menos una instancia.
public class ParentClass{
private static ParentClass mParentInstance = null;
ParentClass(){
mParentInstance = ParentClass.this;
}
void instanceMethod1(){
}
static void staticMethod1(){
mParentInstance.instanceMethod1();
}
public static class InnerClass{
void innerClassMethod1(){
mParentInstance.staticMethod1();
mParentInstance.instanceMethod1();
}
}
}
Nota: - Esto no se puede usar como un método de compilación como este .....
String.valueOf(100);
Necesita una instancia de la clase que contiene el método no estático.
Es como cuando intenta invocar el método no estático startsWith of class String sin una instancia:
String.startsWith("Hello");
Lo que necesita es tener una instancia y luego invocar el método no estático:
String greeting = new String("Hello World");
greeting.startsWith("Hello"); // returns true
Entonces necesita crear e instancia para invocarlo.
No es posible llamar al método no estático dentro del método estático. La lógica detrás de esto es que no creamos un objeto para crear instancias de métodos estáticos, sino que debemos crear un objeto para crear instancias de métodos no estáticos. Por lo tanto, el método no estático no obtendrá el objeto para su creación de instancias dentro del método estático, lo que lo hace incapaz de ser instanciado.
No puedes soslayar esta restricción directamente, no. Pero puede haber algunas cosas razonables que puede hacer en su caso particular.
Por ejemplo, podría simplemente "actualizar" una instancia de su clase en el método estático, luego llamar al método no estático.
Pero puede obtener incluso mejores sugerencias si publica su (s) clase (s) - o una versión reducida de ellas.
Parece que el método realmente debe ser estático (es decir, no tiene acceso a ningún miembro de datos y no necesita una instancia para invocarse). Como usaste el término "clase estática", entiendo que toda la clase probablemente esté dedicada a métodos de utilidad que podrían ser estáticos.
Sin embargo, Java no permite que la implementación de un método definido por la interfaz sea estática. Entonces, cuando (naturalmente) intentas hacer que el método sea estático, obtienes el error "no se puede ocultar el método de instancia". (La Especificación del lenguaje Java menciona esto en la sección 9.4 : "Tenga en cuenta que un método declarado en una interfaz no debe declararse como estático o que se produce un error en tiempo de compilación, porque los métodos estáticos no pueden ser abstractos" ).
Por lo tanto, siempre que el método esté presente en xInterface , y su clase implemente xInterface , no podrá hacer que el método sea estático.
Si no puede cambiar la interfaz (o no quiere), hay varias cosas que puede hacer:
- Haga que la clase sea única: haga que el constructor sea privado y tenga un miembro de datos estáticos en la clase para albergar la única instancia existente. De esta forma, invocará el método en una instancia, pero al menos no creará nuevas instancias cada vez que necesite llamar al método.
- Implemente 2 métodos en su clase: un método de instancia (como se define en
xInterface) y un método estático. El método de instancia consistirá en una única línea que delegue en el método estático.
Primero crea una instancia de clase y llama al método no estático usando esa instancia. p.ej,
class demo {
public static void main(String args[]) {
demo d = new demo();
d.add(10,20); // to call the non-static method
}
public void add(int x ,int y) {
int a = x;
int b = y;
int c = a + b;
System.out.println("addition" + c);
}
}
Puede crear una instancia de la clase sobre la que desea llamar el método, por ejemplo
new Foo().nonStaticMethod();
Puede llamar a un método no estático dentro de uno estático usando: Classname.class.method()
Utilizo una interfaz y creo una instancia anónima de esta manera:
AppEntryPoint.java
public interface AppEntryPoint
{
public void entryMethod();
}
Main.java
public class Main
{
public static AppEntryPoint entryPoint;
public static void main(String[] args)
{
entryPoint = new AppEntryPoint()
{
//You now have an environment to run your app from
@Override
public void entryMethod()
{
//Do something...
System.out.println("Hello World!");
}
}
entryPoint.entryMethod();
}
public static AppEntryPoint getApplicationEntryPoint()
{
return entryPoint;
}
}
No es tan elegante como crear una instancia de esa clase y llamar a su propio método, pero logra esencialmente lo mismo. Solo otra forma de hacerlo.
public class StaticMethod{
public static void main(String []args)throws Exception{
methodOne();
}
public int methodOne(){
System.out.println("we are in first methodOne");
return 1;
}
}
el código anterior no se ejecutó porque el método estático debe tener esa referencia de clase.
public class StaticMethod{
public static void main(String []args)throws Exception{
StaticMethod sm=new StaticMethod();
sm.methodOne();
}
public int methodOne(){
System.out.println("we are in first methodOne");
return 1;
}
}
Esto definitivamente será ejecutado. Porque aquí estamos creando una referencia que nada más que "sm" al usar esa referencia de esa clase que no es más que ( StaticMethod=new Static method() ) estamos llamando al método uno ( sm.methodOne() ).
Espero que esto sea útil.