web-dev-qa-db-fra.com

variable non statique d'accès public statique void main ()

Son dit que variables non statiques ne peuvent pas être utilisés dans une méthode statique.Mais public void statique principal fait.

javavariablesstatic-methodsmainvoid
13
user1526671

Non, ça ne va 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!
  }
}

Également 

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

fonctionnera, puisque a est une variable locale ici, et non une variable d'instance. Une variable locale de méthode est toujours accessible pendant l'exécution de la méthode, que la méthode soit static ou non.

25
Keppil

Oui, la méthode principale peut accéder à des variables non statiques, mais uniquement indirectement via des instances réelles .

Exemple:

public class Main {
    public static void main(String[] args) {
        Example ex = new Example();
        ex.variable = 5;
    }
}

class Example {
    public int variable;
}

Ce que les gens veulent dire quand ils disent "Les variables non statiques ne peuvent pas être utilisées dans une méthode statique" est que des membres non statiques de la même classe ne peut pas être accédé directement (comme indiqué dans réponse Keppils par exemple).

Question connexe:

Mise à jour:

Quand on parle de variables non statiques, on entend implicitement les variables membres . (Puisque les variables locales ne peuvent pas avoir un modificateur statique de toute façon.)

Dans le code

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

vous déclarez une variable locale (qui n'est généralement pas considérée comme non statique, même si elle n'a pas de modificateur statique).

10
aioobe

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

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

En effet, par défaut, lorsque vous appelez une méthode ou une variable, celle-ci accède réellement à this.method() ou à this.variable. Mais dans la méthode main () ou dans toute autre méthode statique (), aucun objet "ce" n'a encore été créé.

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

Pour appeler une méthode ou une variable non statique dans un contexte statique, vous devez d'abord construire l'objet avec un constructeur ou une fabrique, comme vous le feriez n'importe où en dehors de la classe.

Plus de profondeur:

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

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

Cela semble semble envoyer le nouveau thread en veille, mais il en fait se compile en un code comme celui-ci:

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

parce que sleep est une méthode statique qui ne met jamais en sommeil le current thread.

En effet, la variable n'est même pas vérifiée pour la non-nullité (pas plus qu'elle l'était, je crois):

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

Certains IDE peuvent être configurés pour émettre un avertissement ou une erreur pour un code comme celui-ci - vous ne devriez pas le faire, car cela nuit à la lisibilité. (C'est l'une des failles qui a été corrigée par C # ...)

3
Lion

** Ici, vous pouvez voir le tableau qui efface l'accès des membres de données statiques et non statiques dans les méthodes statiques et non statiques. **  static non-static table

3
Sufyan Ahmad

Vous pouvez créer des références non statiques dans des méthodes statiques telles que:

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

Même chose que nous faisons avec la méthode public static void main(String[] args)

0
Nandkumar Tekale
public class XYZ
{
   int i=0;
   public static void increament()
       {
       i++;   
       }
}
public class M
{
    public static void main(String[] args)
    {
    XYZ o1=new XYZ();
    XYZ o2=new XYZ();
    o1.increament(); 
    XYZ.increament(); //system wont be able to know i belongs to which object 
                  //as its increament method(static method)can be called using   class name system 
                  //will be confused changes belongs to which object.
    }
}
0
Abhishek Paithane