Cet article est
Pour ceux qui disent.
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.
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).
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.
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);
}
}
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.
Cette fois, nous avons appris les variables et les portées. Ensuite, les caractéristiques des variables suivantes sont décrites.
Je pense qu'il y a encore des façons d'utiliser ça, Je vais l'omettre ici.
Merci ☕️
Recommended Posts