chiamare il metodo non statico nel metodo statico in Java

Ricevo un errore quando provo a chiamare un metodo non statico in una class statica.

Imansible creare un riferimento statico al metodo non statico methodName () dal tipo playback

Non riesco a rendere il metodo statico in quanto ciò mi dà anche un errore.

Questo metodo statico non può hide il metodo di istanza da xInterface

C’è un modo per aggirare un metodo non statico in un altro metodo statico? (I due metodi sono in pacchetti separati e classi separate).

L’unico modo per chiamare un metodo non statico da un metodo statico consiste nell’avere un’istanza della class che contiene il metodo non statico. Per definizione, un metodo non statico è uno che si chiama ON un’istanza di qualche class, mentre un metodo statico appartiene alla class stessa.

Potresti creare un’istanza della class su cui vuoi chiamare il metodo, ad es

new Foo().nonStaticMethod(); 

Creare innanzitutto un’istanza di class e chiamare il metodo non statico utilizzando tale istanza. per esempio,

 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); } } 
 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; } } 

il codice sopra non viene eseguito perché il metodo statico deve avere quel riferimento di class.

 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; } } 

Questo sarà sicuramente eseguito. Perché qui stiamo creando un riferimento che nient’altro che “sm” usando quel riferimento di quella class che non è altro che ( StaticMethod=new Static method() ) che chiamiamo metodo uno ( sm.methodOne() ).

Spero che questo sarà utile.

Sembra che il metodo dovrebbe essere statico (cioè non accede a nessun membro di dati e non ha bisogno di un’istanza da invocare). Dal momento che hai usato il termine “statica di class”, capisco che l’intera class è probabilmente dedicata a metodi di utilità che potrebbero essere statici.

Tuttavia, Java non consente l’implementazione di un metodo definito dall’interfaccia come statico. Quindi, quando (naturalmente) provi a rendere statico il metodo, ottieni l’errore “can not-hide-the-instance-method”. (La specifica del linguaggio Java lo menziona nella sezione 9.4 : “Si noti che un metodo dichiarato in un’interfaccia non deve essere dichiarato statico, o si verifica un errore in fase di compilazione, perché i metodi statici non possono essere astratti.” )

Quindi, fintanto che il metodo è presente in xInterface e la tua class implementa xInterface , non sarai in grado di rendere statico il metodo.

Se non puoi cambiare l’interfaccia (o non vuoi), ci sono diverse cose che puoi fare:

  • Rendi la class un singleton: rendi il costruttore privato e un membro dei dati statici nella class per mantenere l’unica istanza esistente. In questo modo invocherai il metodo su un’istanza, ma almeno non creerai nuove istanze ogni volta che devi chiamare il metodo.
  • Implementa 2 metodi nella tua class: un metodo di istanza (come definito in xInterface ) e un metodo statico. Il metodo di istanza sarà costituito da una singola riga che delega al metodo statico.

È necessaria un’istanza della class che contiene il metodo non statico.

È come quando provi a invocare il metodo non statico startsWith of class String senza un’istanza:

  String.startsWith("Hello"); 

Quello di cui hai bisogno è avere un’istanza e quindi invocare il metodo non statico:

  String greeting = new String("Hello World"); greeting.startsWith("Hello"); // returns true 

Quindi è necessario creare e istanza per invocarlo.

L’unico modo per chiamare un metodo non statico da un metodo statico consiste nell’avere un’istanza della class che contiene il metodo non statico.

 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*/ } } 

Ci sono due modi:

  1. Chiama il metodo non statico da un’istanza all’interno del metodo statico. Vedi la risposta di fabien per un campione oneliner … anche se lo raccomanderei vivamente. Con il suo esempio crea un’istanza della class e la usa solo per un metodo, solo per averne disposizione in seguito. Non lo consiglio perché tratta un’istanza come una funzione statica.
  2. Cambia il metodo statico in un non statico.

Non puoi aggirare questa restrizione direttamente, no. Ma ci possono essere alcune cose ragionevoli che puoi fare nel tuo caso particolare.

Ad esempio, è ansible semplicemente “aggiornare” un’istanza della class nel metodo statico, quindi chiamare il metodo non statico.

Ma potresti ottenere suggerimenti ancora migliori se pubblichi le tue classi – o una loro versione più snella.

Il modo più semplice per utilizzare un metodo / campo non statico all’interno di un metodo statico o viceversa è …

(Per funzionare ci deve essere almeno un’istanza di questa class)

Questo tipo di situazione è molto comune nello sviluppo di app Android, ad esempio: – Un’attività ha almeno un’istanza.

 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: – Questo non può essere usato come un metodo costruttore come questo …..

 String.valueOf(100); 

Uso un’interfaccia e ne creo un’istanza anonima in questo modo:

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; } } 

Non elegante come creare un’istanza di quella class e chiamare il suo metodo, ma realizza la stessa cosa, essenzialmente. Solo un altro modo per farlo.

Il costruttore è un metodo speciale che in teoria è il “solo” metodo non statico chiamato da qualsiasi metodo statico. altrimenti non è permesso.

Puoi chiamare un metodo non statico all’interno di uno statico usando: Classname.class.method()

Non è ansible chiamare il metodo non statico all’interno del metodo statico. La logica dietro è che non creiamo un object per istanziare il metodo statico, ma dobbiamo creare un object per istanziare il metodo non statico. Quindi il metodo non statico non otterrà l’object per la sua istanziazione all’interno del metodo statico, rendendolo così incapace di essere istanziato.