[Grundkenntnisse in Java] Umfang der Variablen

Einführung

Dieser Artikel ist

• Beginnen Sie mit dem Lernen von Java ――Ich möchte die Grundlagen überprüfen

Für diejenigen, die sagen.

Über den Umfang

Der Bereich ist der Bereich, den die Variable verarbeiten kann. "Diese Variable kann von hier nach hier verwendet werden, aber diese Variable kann nicht von hier nach hier verwendet werden." Es ist so.

Nach dem Deklarieren einer Variablen ist der Abstand zwischen {} der Bereich, in dem die Variable verwendet werden kann.

Wenn Sie diesen Bereich nicht kennen, wird ein Kompilierungsfehler angezeigt Ich werde den Umfang mit den Variablen erklären, die ich erklären werde.

Lokale Variablen

Die Blöcke von {bis} werden als Blöcke bezeichnet, und die Variablen, die in diesen Blöcken verarbeitet werden können, werden als lokale Variablen bezeichnet. Es kann nach der deklarierten Position referenziert werden.

public class local {
  public static void main(String args[]){
    int a = 0;

    if(true){
      int b = 0;
    }
    a = 1;//a ist main{}Kann zwischen referenziert werden
    b = 1;//Kompilierungsfehler, da b außerhalb von if liegt
  }
   a = 2;//Kompilierungsfehler, da er außerhalb von main liegt

   public static void sub(){
     a = 3;//Kompilierungsfehler, da es sich um eine Methode außerhalb von main handelt
   }
}

Wenn Sie lokale Variablen haben, denken Sie möglicherweise, dass es globale Variablen gibt. In Java gibt es keine globale Variable (* Im Prinzip werden in Java keine globalen Variablen verwendet).

Instanzvariable

Jedes Mal, wenn es neu ist, wird im Speicherbereich eine Instanz erstellt. Der Zugriff erfolgt über ** Objektvariablenname **.

food.java

class Food{
  String menu;//Instanzvariable
  int price;//Instanzvariable

  public void Info(){
    System.out.println("Das ist"+ menu + "ist");
    System.out.println("Der Preis ist"+ price + "Es ist ein Kreis");
  }

  public void say(){
    System.out.println("Frisch gebraten"+ menu + "Ist das Beste");
  }
}

Main.java

public class Main {
  public static void main(String args[]){
    Food potato = new Food();//Eine neue Adresse wird im Speicher gesichert(Instanziierung der Lebensmittelklasse)

    potato.menu = "Kartoffel";//potato(Objekt).menu(Instanzvariable)Zu"Kartoffel"Ersatz
    potato.price = 270;//potato(Objekt).price(Instanzvariable)Zu"270"Ersatz

    System.out.println(potato.menu);//Kartoffel

    potato.Info();
    //Das ist Kartoffel
    //Der Preis beträgt 270 Yen

    potato.say();//Frisch gebratene Kartoffeln sind die besten

    Food nugget = new Food();//Eine neue Adresse wird im Speicher gesichert

    nugget.menu = "Nugget";//nugget(Objekt).menu(Instanzvariable)Zu"Nugget"Ersatz
    nugget.price = 580;//nugget(Objekt).price(Instanzvariable)Zu"580"Ersatz

    System.out.println(nugget.menu);//Nugget

    nugget.Info();
    //Dies ist ein Nugget
    //Der Preis beträgt 580 Yen

  }

}

Im Folgenden finden Sie ein Beispiel für einen Kompilierungsfehler

food.java

  public static void say(){
    System.out.println("Frisch gebraten"+ menu + "Ist das Beste");
  }

Wenn Sie die say-Methode von food.java in eine statische Methode ändern, Cannot make a static reference to the non-static field menu Ich werde wütend auf das Gefühl

Main.java

 potato.say();

Dieser Teil ist auch

The static method say() from the type Food should be accessed in a static way Ich werde wütend auf ein Gefühl.

Ich werde später erklären, Wenn Sie es zu einer statischen Methode machen möchten, müssen Sie es mit einer statischen Variablen definieren.

Darüber

Sie können das Schlüsselwort this verwenden, wenn Sie auf Ihre eigene Instanz verweisen. Sie können mit ** this.variable name ** darauf zugreifen. Dies kann weggelassen werden.

Es wird häufig verwendet, um das Ziel zu identifizieren, wenn der Name der lokalen Variablen mit der im Feld der Klasse definierten Variablen übereinstimmt. Lokale Variablen haben Vorrang vor Klassenvariablen.

Bitte schauen Sie sich dieses Beispiel an.

public class Soccer {

  //Instanzvariable
  String player = "Messi";

  public static void main(String[] args){

    //Lokale Variablen
    String player = "Iniesta";

    System.out.println(player + "ist");// イニエスタist
  }
}

Wie bereits erwähnt, wurden lokale Variablen priorisiert. Wenn Sie auf den Player der Klassenvariablen zugreifen, können Sie ihn als this.variable-Namen angeben.

Schlechtes Beispiel dafür: Fußball.java

public class Soccer {

  //Instanzvariable
  String player = "Messi";

  public static void main(String[] args){

    //Lokale Variablen
    String player = "Iniesta";

    System.out.println("Lokale Variablen" + player + "ist");// Lokale Variablenイニエスタist
    System.out.println("Instanzvariable" + this.player + "ist");// Cannot use this in a static context
  }
}

Wie Sie im schlechten Beispiel sehen können, können Sie dies nicht einfach so schreiben, wie es ist.

Richtiges Beispiel: Fußball.java

class Soccer {
  String player = "Messi";

  public void say(String player) {//Machen Sie es durch Argumente unterscheidbar
      System.out.println("Lokale Variablen" + player + "ist");// Lokale Variablenイニエスタist
      System.out.println("Instanzvariable" + this.player + "ist");// クラス変数メッシist
  }
}

Richtiges Beispiel: Drucken.java

public class Print {
  public static void main(String[] args) {
      String player = "Iniesta";
      Soccer sc = new Soccer();
      sc.say(player);
  }
}

statische Variable (Klassenvariable)

Der statische Modifikator wird im Klassenbereich definiert. Der Zugriff erfolgt über ** Klassenname. Statischer Variablenname **. Statische Variablen haben nicht für jedes Objekt einen Wert.

Schauen wir uns ein Beispiel an.

Meiji.java

public class Meiji {
  public static String snack;//Statische Variable

  public void saySnack(){
    System.out.println(snack);
  }
}

Meiji2.java

public class Meiji2 {
  public static void main(String[] args){
    Meiji.snack = "Berg der Pilze";//zu naschen"Berg der Pilze"Wird gelagert
    Meiji say1 = new Meiji();//Instanziierung der Meiji-Klasse
    say1.saySnack();//Berg der Pilze
    Meiji say2 = new Meiji();
    say2.saySnack();//Berg der Pilze

    Meiji.snack = "Takenoko no Sato";//zu naschen"Takenoko no Sato"Wird gelagert
    say1.saySnack();//Takenoko no Sato
    say2.saySnack();//Takenoko no Sato
  }
}

Wie Sie sehen können, gibt es für jedes Objekt keinen Wert. say1 und say2 beziehen sich auf denselben speicherinternen Wert.

Die Verwendung von statischen Variablen ist Ich lerne noch, aber Sie können damit zählen, wie viele Instanzen Sie aus Ihrer Klasse erstellt haben. Ich habe Meiji.java und Meiji2.java etwas früher umgeschrieben.

Meiji.java

public class Meiji {
  public String snack;//Instanzvariable
  public static int count = 0;//Initialisieren Sie statische Variablen

  public void saySnack(){
    System.out.println(snack);
    Meiji.count++;//Name der Klasse.count(statische Variable)Mit 1 angeben und um 1 erhöhen
  }

  public static void snackCnt(){ //statische Methode (Klassenmethode)
    System.out.println(Meiji.count);
  }
}

Meiji2.java

public class Meiji2 {
  public static void main(String[] args){
    Meiji.snackCnt();// 0

    Meiji kinoko = new Meiji();//Instanziierung der Meiji-Klasse
    kinoko.snack = "Berg der Pilze";//kinoko(Objekt).snack(Instanzvariable)Zu"Berg der Pilze"Ersatz
    kinoko.saySnack();//Berg der Pilze

    Meiji.snackCnt();// 1

    Meiji takenoko = new Meiji();
    takenoko.snack = "Takenoko no Sato";
    takenoko.saySnack();//Takenoko no Sato

    Meiji.snackCnt();// 2

  }
}

Da es in der saySnack-Methode hochzählt Sie können sehen, dass die Anzahl mit jedem Aufruf der Methode zunimmt.

Schließlich

Dieses Mal haben wir etwas über Variablen und Bereiche gelernt. Anschließend werden die Merkmale der folgenden Variablen beschrieben.

• Lokale Variablen --Instanzvariablen
• statische Variable (Klassenvariable)

Ich denke, es gibt noch einige Möglichkeiten, dies zu nutzen. Ich werde es hier weglassen.

Danke ☕️