Pour ceux qui viennent de commencer à apprendre la programmation, y compris le langage Java, et ceux qui l'ont déjà appris, pour examen J'écris pour apprendre la portée des variables.
La dernière fois, j'ai appris la Conversion de type. Cette fois à propos de ** portée variable **.
La plage valide de variables qui sont littéralement définies. (La plage dans laquelle la variable peut être utilisée est limitée par l'endroit où la variable est déclarée)
・ Variables locales -Variable d'instance ・ Variable statique
Il existe plusieurs types de noms selon l'endroit où vous les déclarez.
Jetons un coup d'œil à la portée à l'aide d'un exemple simple.
La plage effective est différente pour chaque "{} unité de bloc". Il peut être utilisé dans le bloc après la position où la variable est déclarée.
Main.java
class Main {
public static void main(String args[]) {
String block1 = "Bloc 1";
System.out.println(block1); //Bloc 1
{
String block2 = "Bloc 2";
//Vous pouvez y accéder car c'est dans le bloc qui a déclaré block2
System.out.println(block2); //Bloc 2
//block1 est accessible
System.out.println(block1); //Bloc 1
}
//Comme c'est en dehors du bloc qui a déclaré block2, une erreur de compilation se produira.
System.out.println(block2); // block2 cannot be resolved to a variable
}
}
Ce qui précède est un seul bloc, donc un exemple plus concret ...
** Vous ne pouvez pas accéder aux variables déclarées dans une méthode différente d'une autre méthode. ** **
Main.java
class Main {
public static void main(String args[]) {
//Déclaration et initialisation de la variable block1 dans la méthode main
String block1 = "Bloc 1";
System.out.println(block1); //Bloc 1
}
public static void method() {
//Cette méthode, qui est hors limites, ne peut pas accéder à la variable block1, ce qui entraîne une erreur de compilation.
block1 = "Bloc 3"; // block1 cannot be resolved to a variable
}
}
** Vous ne pouvez pas accéder aux variables déclarées dans l'instruction if. ** **
Main.java
class Main {
public static void main(String args[]) {
String block1 = "Bloc 1";
System.out.println(block1); //Bloc 1
boolean flg = true;
if(flg) {
String block2 = "Bloc 2";
}
//Puisque la variable block2 est en dehors du bloc car elle a été définie dans l'instruction if, une erreur de compilation se produira.
block2 = "Je veux réécrire le bloc 2"; // block2 cannot be resolved to a variable
}
Dans les deux cas, la plage valide de «{} bloc bloc» est différente, l'accès n'est donc pas possible et une erreur de compilation se produit.
Au fait, L'inférence de type de variable locale est disponible depuis JDK 10. Les détails seront résumés dans un article séparé à une date ultérieure, je vais donc l'omettre cette fois.
Une variable déclarée directement sous la définition de classe.
Person.java
class Person {
//Définir des variables sous la classe (variables d'instance)
String name;
int age;
int height;
//Il est également accessible à partir des méthodes de la classe (non accessible à partir des méthodes statiques; voir ci-dessous)
public void checkInfo() {
System.out.print("Nom est"+ name + "、");
System.out.print("L'âge est"+ age + "、");
if(age < 20) {
System.out.print("Mineur.");
}
System.out.println("Quelle est votre taille"+ height + "est.");
}
}
Lorsque plusieurs objets sont créés (instanciés) avec le nouveau mot-clé basé sur la classe Person La valeur de la variable d'instance est différente pour chaque instance et différentes valeurs peuvent être gérées pour chaque objet. Accès avec "nom de variable auquel l'objet est affecté. Nom de variable d'instance".
Main.java
class Main {
public static void main(String args[]) {
Person tanaka = new Person(); //Créer un objet avec le nouveau mot-clé
tanaka.name = "Tanaka"; //Dans le nom de variable tanaka auquel l'objet est affecté, la valeur est affectée au nom de variable d'instance.
tanaka.age = 19; // //La valeur est affectée à la variable d'instance age avec le nom de variable tanaka à laquelle l'objet est affecté.
System.out.println(tanaka.name); //Tanaka
System.out.println(tanaka.age); // 19
//↓ Les variables locales devaient être déclarées et initialisées,
//Les variables d'instance sont automatiquement initialisées.
System.out.println(tanaka.height); // 0
tanaka.checkInfo(); //Le nom est Tanaka, l'âge de 19 ans et il est mineur. La hauteur est de 0.
Person suzuki = new Person(); //Créer un objet avec un nouveau mot-clé
suzuki.name = "Suzuki"; //La valeur est affectée au nom de la variable d'instance avec le nom de la variable suzuki à laquelle l'objet est affecté.
suzuki.age = 51; //La valeur est affectée à la variable d'instance age avec le nom de variable suzuki à laquelle l'objet est affecté.
suzuki.height = 146; //La valeur est affectée à la hauteur de variable d'instance avec le nom de variable suzuki à laquelle l'objet est affecté.
System.out.println(suzuki.name); //Suzuki
System.out.println(suzuki.age); // 51
System.out.println(suzuki.height); // 146
suzuki.checkInfo(); //Il s'appelle Suzuki, il a 51 ans et 146 ans.
}
}
Cependant, il n'est pas accessible à partir de la méthode statique.
Les variables d'instance sont accédées avec ʻun nom de variable assigné à l'objet.nom de variable d'instance`, qui est instancié. Vous ne pouvez pas y accéder sauf si vous spécifiez de quelle instance il s'agit.
Par conséquent, si vous essayez d'y accéder sans être instancié, une erreur de compilation se produira.
Person2.java
class Person2 {
//Définir des variables sous la classe
String name;
int age;
//Aussi accessible depuis les méthodes de la classe
public void checkInfo() {
System.out.print("Nom est"+ name + "、");
System.out.print("L'âge est"+ age + "、");
}
//Les variables d'instance ne sont pas accessibles à partir de méthodes statiques, ce qui entraîne une erreur de compilation
public static void checkAge() {
if(age < 20) {
System.out.print("Mineur."); // Cannot make a static reference to the non-static field age
}
}
}
Lorsque la variable locale et la variable d'instance ont le même nom, utilisez this pour indiquer explicitement la variable d'instance.
-Définir un argument avec le même nom que la variable d'instance dans la fonction de la classe -Lorsque la variable d'instance et l'argument ont le même nom
Person2.java
class Person2 {
//Définir des variables sous la classe
String name;
int age;
public void getName() {
//Si aucun argument n'est reçu, une variable avec le même nom de variable que la variable d'instance peut être définie.
String name = "getName()Le nom d'où j'ai appelé est Yamada";
//Au lieu de sortir la variable d'instance, le nom défini dans cette méthode est émis de préférence.
System.out.println(name);
//Utilisez ceci lorsque vous souhaitez afficher le nom de la variable d'instance
System.out.println("Le nom de la variable d'instance est" + this.name);
}
public void setAge(int age) {
//Lorsque le même nom de variable que la variable d'instance est reçu comme argument,
//Si vous essayez de définir avec le même nom de variable, vous obtiendrez une erreur s'il y a des doublons
// int age = 101; // Duplicate local variable age
//Utilisez ceci comme décrit ci-dessus lors de l'affectation de l'argument reçu à la variable d'instance
this.age = age;
System.out.println("L'âge de la variable d'instance définie par setAge est" + age);
}
}
Main2.java
class Main2 {
//Variable d'instance
public static void main(String[] args) {
Person2 sato = new Person2();
sato.name = "Sato";
sato.getName();
// getName()Le nom d'où j'ai appelé est Yamada
//Le nom de la variable d'instance est affiché sous la forme Sato
sato.setAge(77);
//L'âge de la variable d'instance définie par setAge est affiché comme 77
}
}
Une variable déclarée directement sous la définition de classe. Lors de la déclaration d'une variable, elle est traitée comme une variable statique en spécifiant le modificateur static. La variable d'instance contenait une valeur pour chaque objet, Les variables statiques sont regroupées et conservent leurs valeurs (la même valeur est utilisée pour tous les objets). ''
** Les variables d'instance sont des variables pour chaque instance et les variables statiques (variables de classe) sont des variables pour chaque classe. ** **
Sample.java
class Sample {
int number = 99; //Variable d'instance
static String color = "Jaune"; //variable statique (variable de classe)
//Une méthode pour définir une valeur dans une variable statique (variable de classe)
public void setColor(String value) {
color = value;
}
}
Par conséquent, il est accessible sans instancier la classe.
Nom de la classe.Nom de la variable statique (variable de classe )
Main.java
class Main {
public static void main(String args[]) {
Sample sample1 = new Sample();
sample1.number = 10;
System.out.println(sample1.number); // 10
sample1.setColor("rouge");
System.out.println(Sample.color); //rouge
Sample sample2 = new Sample();
//Puisque le nombre, qui est une variable d'instance, est conservé pour chaque objet, la valeur initiale de 99 est incluse.
System.out.println(sample2.number); // 99
//variable statique (variable de classe)Parce que la couleur de est une valeur commune
//Le "jaune" par défaut est sample1.Le rouge a été réglé au moment de setColor.
//Par conséquent, si vous accédez à la variable statique (variable de classe) ici, elle sera affichée en rouge.
System.out.println(Sample.color); //rouge
}
}
Puisque les variables statiques (variables de classe) sont des variables communes de la classe, tout changement affectera toutes les parties utilisées.
Exemple) Lorsque vous souhaitez conserver des données sur le nombre de personnes créées.
Human.java
class Human {
//Variable d'instance
String name;
//variable statique(Variable de classe)
static int count = 0;
//Variables statiques une fois instanciées(Variable de classe)À+1 faire
Human() {
count++;
}
public static void humanCount() {
//Vérifiez combien de personnes ont été créées
System.out.println(count + "Personne créée");
}
}
Main.java
class Main {
public static void main(String[] args) {
Human yamada = new Human();
yamada.name = "Yamada";
System.out.println(yamada.name); //Yamada
//Variables statiques de sortie (variables de classe)
System.out.println(Human.count); // 1
Human takeda = new Human();
takeda.name = "Takeda";
System.out.println(takeda.name); //Takeda
//Variables statiques de sortie (variables de classe)
System.out.println(Human.count); // 2
Human oota = new Human();
oota.name = "Ota";
System.out.println(oota.name); //Ota
//Variables statiques de sortie (variables de classe)
System.out.println(Human.count); // 3
Human.humanCount(); //Résultat que 3 personnes ont été créées
}
}
J'ai appris la portée des variables.
** Si vous programmez sans connaître la portée ... **
・ ʻUne erreur peut se produire ・Vous pouvez attribuer une valeur à une variable à un endroit involontaire (elle a été attribuée même si vous n'aviez pas l'intention de l'attribuer)`
Cela peut causer des problèmes tels que des mouvements inattendus.
Je pense que les problèmes ci-dessus peuvent être évités en le mettant en œuvre en tenant compte de la plage d'influence de la portée.
La prochaine fois, je me pencherai sur le fonctionnement des chaînes de caractères (en préparation).
Recommended Posts