La variable Non statique ne peut pas être référencée à partir d'un contexte statique

Vous devez comprendre la différence entre une classe et une instance de cette classe. Si vous voyez une voiture dans la rue, vous savez immédiatement que c'est une voiture même si vous ne pouvez pas voir quel modèle ou type. C'est parce que vous comparez ce que vous voyez avec le classe "voiture". La classe contient, qui est similaire à toutes les voitures. Pensez-y comme un modèle ou une idée.

en même temps, la voiture que vous voyez est un exemple de la classe "Voiture" puisqu'elle a tout les propriétés que vous attendez: Il y a quelqu'un de conduire, il a un moteur, des roues.

Si la classe dit: "toutes les voitures ont une couleur" et l'instance dit "cette voiture est rouge".

dans le monde OO, vous définissez la classe et à l'intérieur de la classe, vous définissez un champ de type Color . Lorsque la classe est instanciée (lorsque vous créez une instance spécifique), la mémoire est réservée à la couleur et vous pouvez donner une couleur à cette instance spécifique. Depuis ces attributs sont spécifiques, ils ne sont pas statiques.

les méthodes et les champs statiques sont partagés avec toutes les instances. Ils sont pour des valeurs qui sont spécifiques à la classe et pas une instance spécifique. Pour les méthodes, ce sont généralement des méthodes d'aide globale (comme Integer.parseInt() ). Pour les champs, ce sont généralement des constantes (comme les types de voiture, c'est-à-dire quelque chose où vous avez un ensemble limité qui ne change pas souvent).

pour résoudre votre problème, vous devez instancier un instance (create an object) de votre classe afin que l'exécution puisse réserver de la mémoire pour l'instance (sinon, différentes instances s'écraseraient l'une sur l'autre que vous ne voulez pas).

dans votre cas, essayez ce code comme un bloc de départ:

public static void main (String[] args)
{
    try
    {
        MyProgram7 obj = new MyProgram7 ();
        obj.run (args);
    }
    catch (Exception e)
    {
        e.printStackTrace ();
    }
}

// instance variables here

public void run (String[] args) throws Exception
{
    // put your code here
}

la nouvelle méthode main() crée une instance de la classe qu'elle contient (sonne étrange mais puisque main() est créé avec la classe au lieu de l'instance, elle peut le faire) et appelle ensuite une méthode de l'instance ( run() ).

les champs et méthodes statiques sont connectés à la classe elle-même et non à ses instances. Si vous avez une classe A , "normal" méthode b , et une méthode statique c , et vous faire un exemple a de votre classe A , les appels à A.c() et a.b() sont valides. La méthode c() ne sait pas quelle instance est connectée, elle ne peut donc pas utiliser des champs non statiques.

la solution pour vous est que vous faites vos champs statiques ou vos méthodes non statiques. Vous main pourrait ressembler à cela alors:

class Programm {
  public static void main(String[] args){
    Programm programm = new Programm();
    programm.start();
  }
  public void start(){
    // can now access non-static fields
  }
}

le mot-clé static modifie le cycle de vie d'une méthode ou d'une variable au sein d'une classe. Une méthode ou variable static est créée au moment où une classe est chargée. Une méthode ou une variable qui n'est pas déclarée comme static n'est créée que lorsque la classe est instanciée comme un objet par exemple en utilisant l'opérateur new .

Le cycle de vie d'une classe, en termes généraux, est:

1. le code source de la classe est écrit en créant un modèle ou modèle ou tampon qui peut ensuite être utilisé pour
2. créer un objet avec l'opérateur new en utilisant la classe pour créer une instance de la classe en tant qu'objet réel et puis quand fait avec l'objet
3. détruisez l'objet en récupérant les ressources qu'il détient comme la mémoire pendant le ramassage des ordures.

afin d'avoir un point d'entrée initial pour une application, Java a adopté la convention que le programme Java doit avoir une classe qui contient une méthode avec un nom convenu ou spécial. Cette méthode spéciale est appelée main() . Puisque la méthode doit exister que la classe contenant la méthode principale ait été instanciée ou non, la méthode main() doit être déclarée avec le modificateur static de sorte que dès que la classe est chargée, la méthode main() est disponible.

le résultat est que lorsque vous démarrez votre Java application par une ligne de commande telle que java helloworld une série d'actions se produisent. Tout d'abord, une Machine virtuelle Java est lancée et initialisée. Ensuite, le helloworld.le fichier de classe contenant le code Java compilé est chargé dans la machine virtuelle Java. Ensuite, la machine virtuelle Java recherche une méthode dans la classe helloworld qui s'appelle main(String [] args) . cette méthode doit être static pour qu'elle existe même si la classe n'a pas été instanciée comme un objet. Java La Machine virtuelle ne crée pas une instance de la classe en créant un objet à partir de la classe. Il charge juste la classe et commence l'exécution à la méthode main() .

ainsi vous devez créer une instance de votre classe comme un objet et ensuite vous pouvez accéder aux méthodes et variables de la classe qui n'ont pas été déclarées avec le modificateur static . Une fois que votre programme Java a commencé avec la fonction main() , vous pouvez alors utiliser toutes les variables ou méthodes qui avoir le modificateur de static puisqu'ils existent dans la classe à charger.

cependant, les variables et les méthodes de la classe qui sont en dehors de la méthode main() qui n'ont pas le modificateur static ne peuvent pas être utilisées tant qu'une instance de la classe n'a pas été créée comme un objet dans la méthode main() . Après avoir créé l'objet, vous pouvez alors utiliser les variables et les méthodes de l'objet. Une tentative d'utiliser les variables et les méthodes la classe qui n'a pas le modificateur static sans passer par un objet de la classe est attrapée par le compilateur Java au moment de la compilation et signalée comme une erreur.

import java.io.*;

class helloworld {
    int myInt;      // this is a class variable that is unique to each object
    static int myInt2;  // this is a class variable shared by all objects of this class

    static void main (String [] args) {
        // this is the main entry point for this Java application
        System.out.println ("Hello, World\n");
        myInt2 = 14;    // able to access the static int
        helloworld myWorld = new helloworld();
        myWorld.myInt = 32;   // able to access non-static through an object
    }
}

analysons d'abord votre programme.. Dans votre programme, votre première méthode est main() , et garder à l'esprit c'est la méthode statique... Ensuite, vous déclarez la variable locale de la méthode (compareCount, bas, haut, etc..). La portée de cette variable n'est que la méthode déclarée, qu'il s'agisse d'une méthode statique ou non statique. Donc vous ne pouvez pas utiliser ces variables en dehors de cette méthode. C'est l'erreur de base u.

ensuite, nous arrivons au point suivant. Vous avez dit statique est de vous tuer. (Il peut être de vous tuer, mais il ne donne de la vie à votre programme!!) D'abord, vous devez comprendre la chose fondamentale. *La méthode statique n'appelle que la méthode statique et n'utilise que la variable statique. * La variable statique ou la méthode statique ne dépendent d'aucune instance de cette classe. (i.e. si vous changez n'importe quel état de la variable statique il reflétera dans tous les objets de la classe) *Pour cette raison, vous l'appelez comme une variable de classe ou une méthode de classe. Et beaucoup plus est-il à propos de l' "statique" mot-clé. J'espère que maintenant vous avez l'idée. Changer d'abord la portée de la variable et la déclarer comme statique (pour pouvoir l'utiliser dans les méthodes statiques).

Et le conseil pour vous est: vous avez mal compris l'idée de la portée des variables statiques et les fonctionnalités. Obtenez de l'idée claire à ce sujet.

la chose très fondamentale est les variables statiques ou les méthodes statiques sont au niveau de la classe. Les variables ou méthodes au niveau de la classe sont chargées avant les méthodes ou variables au niveau de l'instance.Et évidemment la chose qui n'est pas chargée ne peut pas être utilisée. Donc le compilateur java qui ne laisse pas les choses à être manipulées au moment de l'exécution résout au moment de la compilation. C'est pourquoi il vous donne des erreurs les choses non statiques ne peuvent pas être référées à partir du contexte statique. Vous avez juste besoin de lire à propos de class Level Scope, Instance Level Scope et une Portée Locale.

pour pouvoir y accéder à partir de vos méthodes statiques ils doivent être des variables membres statiques, comme ceci:

public class MyProgram7 {
  static Scanner scan = new Scanner(System.in);
  static int compareCount = 0;
  static int low = 0;
  static int high = 0;
  static int mid = 0;  
  static int key = 0;  
  static Scanner temp;  
  static int[]list;  
  static String menu, outputString;  
  static int option = 1;  
  static boolean found = false;

  public static void main (String[]args) throws IOException {
  ...

Maintenant vous pouvez ajouter/utiliser des instances avec dans la méthode

public class Myprogram7 {

  Scanner scan;
  int compareCount = 0;
  int low = 0;
  int high = 0;
  int mid = 0;  
  int key = 0;  
  Scanner temp;  
  int[]list;  
  String menu, outputString;  
  int option = 1;  
  boolean found = false;  

  private void readLine() {

  }

  private void findkey() {

  }

  private void printCount() {

  }
  public static void main(String[] args){

    Myprogram7 myprg=new Myprogram7();
    myprg.readLine();
    myprg.findkey();
    myprg.printCount();
  }
}

je vais essayer de vous expliquer la chose statique. Tout d'abord les variables statiques n'appartiennent à aucune instance particulière de la classe. Ils sont reconnus par le nom de la classe. Les méthodes statiques n'appartiennent à nouveau à aucune instance particulière. Ils peuvent accéder qu'aux variables statiques. Imagine que tu appelles MyClass.myMethod() et myMethod est une méthode statique. Si vous utilisez des variables non statiques à l'intérieur de la méthode, comment diable pourrait-il savoir quelles variables utiliser? C'est pourquoi vous peut utiliser des méthodes statiques seulement des variables statiques. Je répète qu'ils n'appartiennent à aucune instance particulière.

• La première chose est de connaître la différence entre une instance d'une classe, et la classe elle-même. Une classe modélise certaines propriétés, et le comportement du tout dans le contexte de ces propriétés. Une instance définira des valeurs spécifiques pour ces propriétés.

• Tout ce qui est lié au mot-clé statique est disponible dans le contexte de la classe plutôt que dans le contexte d'une instance de la classe

• comme corollaire de ce qui précède

  1. les variables d'une méthode ne peuvent pas être statiques
  2. les champs statiques et les méthodes doivent être invoqués en utilisant le nom de classe, par exemple MyProgram7.principal.(..)

• la durée de vie d'un champ statique/méthode est équivalente à la durée de vie de votre application

E. G. Dire, la voiture a la couleur de la propriété, et montre le comportement "mouvement". Un exemple de la voiture serait une Volkswagen Beetle rouge en mouvement à 25 km / h.

Maintenant une propriété statique de la voiture serait le nombre de roues (4) sur la route, et cela s'applique à toutes les voitures.

HTH

c'est diff à expliquer sur mot clé statique pour tous les débutants.

Vous apprendrez à le connaître clairement lorsque vous travaillerez davantage avec les Classes et les objets.

|*| Statique : éléments Statiques peuvent être appelées avec un Nom de Classe

Si vous observez dans les codes, certaines fonctions sont directement appelées avec des noms de classe comme

NamCls.NamFnc();

System.out.println();

c'est parce que NamFnc et println seront déclarés en utilisant le mot clé static avant eux.

| * / Non Static: les éléments Non statiques peuvent être appelés avec la Variable de classe

Si ce n'est pas statique, vous avez besoin d'une variable de la classe,

mettre point après la variable de classe et

alors appelez la fonction.

NamCls NamObjVar = new NamCls();
NamObjVar.NamFnc();

| * / statique et non statique fonction dans la classe :

public class NamCls
{
    public static void main(String[] args)
    {
        PlsPrnFnc("Tst Txt");

        NamCls NamObjVar = new NamCls();
        NamObjVar.PrnFnc("Tst Txt");
    }

    static void PlsPrnFnc(String SrgPsgVal)
    {
        System.out.println(SrgPsgVal);
    }

    void PrnFnc(String SrgPsgVal)
    {
        System.out.println(SrgPsgVal);
    }
}

public class NamCls
{
    public static void main(String[] args)
    {
        NamTicCls NamTicVaj = new NamTicCls();
        NamTicVaj.PrnFnc("Tst Txt");

        NamCls NamObjVar = new NamCls();
        NamNicCls NamNicVar = NamObjVar.new NamNicCls();
        NamNicVar.PrnFnc("Tst Txt");
    }

    static class NamTicCls
    {
        void PrnFnc(String SrgPsgVal)
        {
            System.out.println(SrgPsgVal);
        }
    }

    class NamNicCls
    {
        void PrnFnc(String SrgPsgVal)
        {
            System.out.println(SrgPsgVal);
        }
    }
}

avant d'appeler une méthode d'instance ou une variable d'instance, il faut un objet(Instance). Quand la variable d'instance est appelée depuis le compilateur de méthode statique, il ne sait pas à quel objet appartient cette variable. Parce que les méthodes statiques n'ont pas d'objet (une seule copie toujours). Lorsque vous appelez une variable d'instance ou des méthodes d'instance à partir de la méthode d'instance, elle renvoie à l'objet this . Il signifie que la variable appartient à un objet créé et chaque objet est propre copie de méthodes d'instance et variables.

les variables statiques sont marquées comme static et les variables d'instance n'ont pas de mot-clé spécifique.

C'est ClassLoader responsable de charger les fichiers de classe.Voyons ce qui se passe quand on écrit nos propres cours.

exemple 1:

class StaticTest {

      static int a;
      int b;
      int c;
}

maintenant nous pouvons voir que la classe "StaticTest" a 3 champs.Mais en fait, il n'existe pas de variable membre b,C.Mais pourquoi ???. OK, de Peur de la voir. Ici B, C sont variables d'instance.Puisque la variable d'instance obtient la mémoire au moment de la création de l'objet. Donc ici b, c n'ont pas encore de mémoire. C'est pourquoi il n'y a pas de b,C. Il n'y a donc qu'une seule existence. Pour ClassLoader, il n'y a qu'une seule information sur A. ClassLoader ne reconnaît pas encore b, C parce que son objet n'est pas encore instancié.

voyons un autre exemple: Exemple 2:

class StaticTest {

      public void display() {
          System.out.println("Static Test");
      }


      public static void main(String []cmd) {

             display();       
      }

}

maintenant si nous essayons de compiler ce compilateur de code donnera l'erreur CE. CE: la méthode non-statique display () ne peut pas être référencée à partir d'un contexte statique.

maintenant pour ClassLoader il semble comme:

class StaticTest {

      public static void main(String []cmd) {

             display();       
      }

}

dans L'exemple 2, l'erreur CE est due au fait que nous appelons la méthode non statique à partir d'un contexte statique. Il n'est donc pas possible pour ClassLoader de reconnaître method display() au moment de la compilation.Donc une erreur de temps de compilation est survenue.

class MyProgram
{
  int count = 0; // non-static variable / instance variable
  public static void main (String[] args) // static method
  {
    MyProgram c = new MyProgram(); // create c as reference variable
    System.out.println(c.count); // call non-static variable using a reference variable name (c)
  }
}

Les compilateurs de penser "je ne sais pas qui de l'objet de l'intance variable dont vous parlez".

Java En Ligne

body, html, iframe { 
  width: 100% ;
  height: 100% ;
  overflow: hidden ;
}

<iframe src="https://ideone.com/SIDcv1" ></iframe>

essayez ceci..

public class StaticTest {

    private int count=0;
    public static void main(String args[]) throws IOException {
        StaticTest test = new StaticTest(); //accessing static variable by creating an instance of class
        System.out.println(test.count);
    }       
}

j'espère que ça vous aidera..!