[Connaissance de base de Java] Portée des variables

introduction

Cet article est

• Commencer à apprendre Java ――Je veux revoir les bases

Pour ceux qui disent.

À propos de la portée

La portée est la plage que la variable peut gérer. "Cette variable peut être utilisée d'ici à ici, mais cette variable ne peut pas être utilisée d'ici à ici." ` C'est comme ça.

Après avoir déclaré une variable, l'espace entre {} est la plage dans laquelle la variable peut être utilisée.

Si vous n'êtes pas conscient de cette portée, vous obtiendrez une erreur de compilation, donc J'expliquerai la portée avec les variables que je vais expliquer.

Variables locales

Les blocs de {à} sont appelés blocs, et les variables qui peuvent être gérées dans ces blocs sont appelées variables locales. Il peut être référencé après la position déclarée.

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

    if(true){
      int b = 0;
    }
    a = 1;//a est principal{}Peut être référencé entre
    b = 1;//Erreur de compilation car b est en dehors de if
  }
   a = 2;//Erreur de compilation car elle est en dehors de main

   public static void sub(){
     a = 3;//Erreur de compilation car il s'agit d'une méthode en dehors de main
   }
}

Si vous avez des variables locales, vous pourriez penser qu'il existe des variables globales, Il n'y a pas de variable globale en Java (* En principe, les variables globales ne sont pas utilisées en Java).

Variable d'instance

Une instance est créée dans la zone mémoire à chaque fois qu'elle est nouvelle. Il est accessible par ** nom de variable object.instance **.

food.java

class Food{
  String menu;//Variable d'instance
  int price;//Variable d'instance

  public void Info(){
    System.out.println("C'est"+ menu + "est");
    System.out.println("Le prix est"+ price + "C'est un cercle");
  }

  public void say(){
    System.out.println("Fraîchement frit"+ menu + "Est le meilleur");
  }
}

Main.java

public class Main {
  public static void main(String args[]){
    Food potato = new Food();//Une nouvelle adresse est sécurisée en mémoire(Instanciation de classe alimentaire)

    potato.menu = "Patate";//potato(objet).menu(Variable d'instance)À"Patate"Remplacer
    potato.price = 270;//potato(objet).price(Variable d'instance)À"270"Remplacer

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

    potato.Info();
    //C'est de la pomme de terre
    //Le prix est de 270 yens

    potato.say();//Les pommes de terre fraîchement frites sont les meilleures

    Food nugget = new Food();//Une nouvelle adresse est sécurisée en mémoire

    nugget.menu = "pépite";//nugget(objet).menu(Variable d'instance)À"pépite"Remplacer
    nugget.price = 580;//nugget(objet).price(Variable d'instance)À"580"Remplacer

    System.out.println(nugget.menu);//pépite

    nugget.Info();
    //C'est une pépite
    //Le prix est de 580 yens

  }

}

Ensuite, voici un exemple d'erreur de compilation suivant

food.java

  public static void say(){
    System.out.println("Fraîchement frit"+ menu + "Est le meilleur");
  }

Si vous remplacez la méthode dite de food.java par une méthode statique, Cannot make a static reference to the non-static field menu Je me fâche avec le sentiment

Main.java

 potato.say();

Cette partie est aussi

The static method say() from the type Food should be accessed in a static way Je me fâche avec un sentiment.

Je vous expliquerai plus tard, Si vous voulez en faire une méthode statique, vous devez la définir avec une variable statique.

À propos de ça

Vous pouvez utiliser le mot-clé this lorsque vous vous référez à votre propre instance. Vous pouvez y accéder avec ** this.variable name **. Ceci. Peut être omis.

Il est souvent utilisé pour identifier la cible lorsque le nom de la variable locale est le même que la variable définie dans le champ de la classe. Les variables locales ont priorité sur les variables de classe.

Veuillez jeter un œil à cet exemple.

public class Soccer {

  //Variable d'instance
  String player = "Messi";

  public static void main(String[] args){

    //Variables locales
    String player = "Iniesta";

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

Comme mentionné précédemment, les variables locales ont été priorisées. Lors de l'accès au lecteur de la variable de classe, il peut être spécifié en lui donnant le nom this.variable.

Mauvais exemple d'utilisation de ceci: Soccer.java

public class Soccer {

  //Variable d'instance
  String player = "Messi";

  public static void main(String[] args){

    //Variables locales
    String player = "Iniesta";

    System.out.println("Variables locales" + player + "est");// Variables localesイニエスタest
    System.out.println("Variable d'instance" + this.player + "est");// Cannot use this in a static context
  }
}

Comme vous pouvez le voir dans le mauvais exemple, vous ne pouvez pas simplement l'écrire tel quel.

Exemple correct: football.java

class Soccer {
  String player = "Messi";

  public void say(String player) {//Faites-le distinguer par argument
      System.out.println("Variables locales" + player + "est");// Variables localesイニエスタest
      System.out.println("Variable d'instance" + this.player + "est");// クラス変数メッシest
  }
}

Exemple correct: Imprimer.java

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

variable statique (variable de classe)

Le modificateur statique est défini dans la zone de classe. Il est accessible par ** nom de classe.nom de variable statique **. Les variables statiques n'ont pas de valeur pour chaque objet.

Regardons un exemple.

Meiji.java

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

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

Meiji2.java

public class Meiji2 {
  public static void main(String[] args){
    Meiji.snack = "Montagne de champignons";//à grignoter"Montagne de champignons"Est stocké
    Meiji say1 = new Meiji();//Instanciation de la classe Meiji
    say1.saySnack();//Montagne de champignons
    Meiji say2 = new Meiji();
    say2.saySnack();//Montagne de champignons

    Meiji.snack = "Takenoko no Sato";//à grignoter"Takenoko no Sato"Est stocké
    say1.saySnack();//Takenoko no Sato
    say2.saySnack();//Takenoko no Sato
  }
}

Comme vous pouvez le voir, il n'y a pas de valeur pour chaque objet, say1 et say2 font référence à la même valeur en mémoire.

L'utilisation de variables statiques est J'étudie toujours, mais vous pouvez l'utiliser pour compter le nombre d'instances que vous avez créées à partir de votre classe. J'ai réécrit Meiji.java et Meiji2.java un peu plus tôt.

Meiji.java

public class Meiji {
  public String snack;//Variable d'instance
  public static int count = 0;//Initialiser les variables statiques

  public void saySnack(){
    System.out.println(snack);
    Meiji.count++;//nom de la classe.count(variable statique)Spécifiez avec et augmentez de 1
  }

  public static void snackCnt(){ //méthode statique (méthode de classe)
    System.out.println(Meiji.count);
  }
}

Meiji2.java

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

    Meiji kinoko = new Meiji();//Instanciation de la classe Meiji
    kinoko.snack = "Montagne de champignons";//kinoko(objet).snack(Variable d'instance)À"Montagne de champignons"Remplacer
    kinoko.saySnack();//Montagne de champignons

    Meiji.snackCnt();// 1

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

    Meiji.snackCnt();// 2

  }
}

Puisqu'il compte dans la méthode saySnack Vous pouvez voir que le nombre augmente chaque fois que la méthode est appelée.

finalement

Cette fois, nous avons appris les variables et les portées. Ensuite, les caractéristiques des variables suivantes sont décrites.

• Variables locales --Variables d'instance
• variable statique (variable de classe)

Je pense qu'il y a encore des façons d'utiliser ça, Je vais l'omettre ici.

Merci ☕️