public static void main () de l'accès non statique de la variable

Non, il ne le fait pas.

public class A {
  int a = 2;
  public static void main(String[] args) {
    System.out.println(a); //won't compile!!
  }
}

mais

public class A {
  static int a = 2;
  public static void main(String[] args) {
    System.out.println(a); //this works!
  }
}

ou si vous instanciez A

public class A {
  int a = 2;
  public static void main(String[] args) {
    A myA = new A();
    System.out.println(myA.a); //this works too!
  }
}

Aussi

public class A {
  public static void main(String[] args) {
    int a = 2;
    System.out.println(a); //this works too!
  }
}

de travail, depuis a est une variable locale, ici, et pas une variable d'instance. Une méthode de variable locale est toujours accessible pendant l'exécution de la méthode, peu importe si la méthode est static ou pas.

OriginalL'auteur Keppil

La principale méthode n'a pas accès aux membres non statique.

final public class Demo
{
   private String instanceVariable;
   private static String staticVariable;

   public String instanceMethod()
   {
      return "instance";
   }

   public static String staticMethod()
   {
      return "static";
   }

   public static void main(String[] args)
   {
      System.out.println(staticVariable); //ok
      System.out.println(Demo.staticMethod()); //ok

      System.out.println(new Demo().instanceMethod()); //ok
      System.out.println(new Demo().instanceVariable); //ok

      System.out.println(Demo.instanceMethod()); //wrong
      System.out.println(instanceVariable);         //wrong 
   }
}

C'est parce que par défaut, lorsque vous appelez une méthode ou une variable, il est vraiment accéder à la this.method() ou cette.variable. Mais dans la méthode main() ou toute autre méthode statique(), pas de "ce" objets n'a pas encore été créé.

En ce sens, la méthode statique n'est pas une partie de l'objet instance de la classe qui le contient. C'est l'idée derrière les classes utilitaires.

D'appeler n'importe quel non-statique méthode ou une variable dans un contexte statique, vous devez d'abord construire l'objet avec un constructeur ou d'une usine comme la votre serait n'importe où en dehors de la classe.

---

Plus en profondeur:

Fondamentalement, c'est une faille dans la conception de Java de l'OMI qui permet aux membres statiques (les méthodes et les champs) pour la référence comme si ils étaient les membres de l'instance. Cela peut être très déroutant dans le code comme ceci:

Thread newThread = new Thread(runnable);
newThread.start();
newThread.sleep(1000);

Que semble comme c'est d'envoyer le nouveau thread pour dormir, mais il fait compile vers le bas dans le code comme ceci:

Thread newThread = new Thread(runnable);
newThread.start();
Thread.sleep(1000);

parce que sleep est une méthode statique qui n'a jamais fait l' actuel fil du sommeil.

En effet, la variable n'est même pas vérifié pour les non-nullité (plus; il utilisé pour être, je crois):

Thread t = null;
t.sleep(1000);

Quelques IDEs peut être configuré pour émettre un avertissement ou d'erreur de code comme celui - ci, vous ne devriez pas le faire, que ça fait mal la lisibilité. (C'est un des défauts qui ont été corrigés en C#...)

OriginalL'auteur Lion

Vous pouvez créer des non-statique des références à des méthodes statiques comme :

static void method() {
   A a = new A();
}

Même chose que nous faisons dans le cas de public static void main(String[] args) méthode

OriginalL'auteur Nandkumar Tekale