appel d'une méthode non statique dans une méthode statique en Java [dupliquer]

Vous pouvez créer une instance de la classe sur laquelle vous souhaitez appeler la méthode, par exemple

new Foo().nonStaticMethod();

Créez D'abord une Instance de classe et appelez la méthode non statique en utilisant cette instance. e.g,

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

Le code ci-dessus n'est pas exécuté car la méthode statique doit avoir cette référence de classe.

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

Ce sera certainement être exécuté. Parce qu'ici nous créons une référence qui n'est rien d'autre que " sm " en utilisant cette référence de cette classe qui n'est rien mais (StaticMethod=new Static method()), nous appelons la méthode (sm.methodOne()).

J'espère que cela sera utile.

Il semble que la méthode vraiment devrait être statique (c'est-à-dire qu'elle n'accède à aucun membre de données et qu'elle n'a pas besoin d'une instance pour être invoquée). Puisque vous avez utilisé le terme "classe statique", je comprends que toute la classe est probablement dédiée aux méthodes de type utilitaire qui pourraient être statiques.

Cependant, Java ne permet pas que l'implémentation d'une méthode définie par l'interface soit statique. Donc, quand vous (naturellement) essayez de rendre la méthode statique, vous obtenez le "ne peut-cacher-le-instance-méthode d'erreur". (La spécification du langage Java le mentionne dans la section 9.4: "notez qu'une méthode déclarée dans une interface ne doit pas être déclarée statique, ou une erreur de compilation se produit, car les méthodes statiques ne peuvent pas être abstraites.")

Tant que la méthode est présente dans xInterface et que votre classe implémente xInterface, Vous ne pourrez pas rendre la méthode statique.

Si vous ne pouvez pas changer l'interface (ou ne voulez pas), il y en a plusieurs ce que vous pouvez faire:

• faire de la classe un singleton: rendre le constructeur privé, et avoir un membre de données statiques dans la classe pour contenir la seule instance existante. De cette façon, vous invoquerez la méthode sur une instance, mais au moins vous ne créerez pas de nouvelles instances chaque fois que vous devrez appeler la méthode.
• implémentez 2 méthodes dans votre classe: une méthode d'instance (telle que définie dans xInterface) et une méthode statique. La méthode d'instance sera composée d'une seule ligne qui délègue à la méthode statique.

Vous avez besoin d'une instance de la classe contenant la méthode non statique.

Est comme lorsque vous essayez d'appeler la méthode non statique startsWith de la classe String sans instance:

 String.startsWith("Hello");

Ce dont vous avez besoin est d'avoir une instance, puis d'appeler la méthode non statique:

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

Vous devez donc créer et instance pour l'invoquer.

La seule façon d'appeler un non-méthode statique à partir d'une méthode statique est d'avoir une instance de la classe contenant la non méthode statique.

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

Il y a deux façons:

1. appelez la méthode non statique à partir d'une instance de la méthode statique. Voir la réponse de fabien pour un échantillon oneliner... bien que je recommande fortement contre elle. Avec son exemple, il a crée une instance de la classe et l'utilise seulement pour une méthode, pour en disposer plus tard. Je ne le recommande pas car il traite une instance comme une fonction statique.
2. remplacez la méthode statique par une méthode non statique.

Vous ne pouvez pas contourner cette restriction directement, non. Mais il peut y avoir des choses raisonnables que vous pouvez faire dans votre cas particulier.

Par exemple, vous pouvez simplement "nouvelle" une instance de votre classe dans la méthode statique, puis d'appeler le non méthode statique.

Mais vous pourriez obtenir des suggestions encore meilleures si vous publiez votre(vos) Classe (S)-ou une version allégée d'entre eux.

Le moyen le plus simple d'utiliser une méthode/un champ non statique dans une méthode statique ou vice versa est...

(pour fonctionner, il doit y avoir au moins une instance de cette classe)

Ce type de situation est très courant dans le développement d'applications android, par exemple:- une activité a au moins une instance.

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

Note: - cela ne peut pas être utilisé comme une méthode de builder comme celle-ci.....

String.valueOf(100);

J'utilise une interface et en crée une instance anonyme comme ceci:

AppEntryPoint.java

public interface AppEntryPoint
{
    public void entryMethod();
}

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

Pas aussi élégant que de créer une instance de cette classe et d'appeler sa propre méthode, mais accomplit la même chose, essentiellement. Juste une autre façon de le faire.

Constructeur est une méthode spéciale qui, en théorie, est la "seule" non-statique méthode appelée par une méthode statique. sinon il n'est pas permis.

Vous pouvez appeler une méthode non statique dans une méthode statique en utilisant: Classname.class.method()

Il n'est pas possible d'appeler une méthode non statique dans une méthode statique. La logique derrière cela est que nous ne créons pas un objet pour instancier une méthode statique, mais nous devons créer un objet pour instancier une méthode non statique. Donc, la méthode non statique n'obtiendra pas d'objet pour son instanciation dans la méthode statique, ce qui la rend incapable d'être instanciée.