Für diejenigen, die gerade angefangen haben, Programmieren einschließlich der Java-Sprache zu lernen, und diejenigen, die es bereits gelernt haben, zur Überprüfung Ich schreibe, um den Umfang der Variablen zu lernen.
Beim letzten Mal habe ich etwas über [Typkonvertierung] erfahren (https://qiita.com/morioheisei/items/28ab5fd69570e01cd317). Diesmal über ** variablen Umfang **.
Der gültige Bereich von Variablen, die buchstäblich definiert sind. (Der Bereich, in dem die Variable verwendet werden kann, ist durch die Stelle begrenzt, an der die Variable deklariert wird.)
・ Lokale Variablen -Instanzvariable ・ Statische Variable
Es gibt mehrere Arten von Namen, je nachdem, wo Sie sie deklarieren.
Schauen wir uns den Umfang anhand eines einfachen Beispiels an.
Der effektive Bereich ist für jede "{} Blockeinheit" unterschiedlich. Es kann im Block nach der Position verwendet werden, an der die Variable deklariert ist.
Main.java
class Main {
public static void main(String args[]) {
String block1 = "Block 1";
System.out.println(block1); //Block 1
{
String block2 = "Block 2";
//Sie können darauf zugreifen, da es sich in dem Block befindet, der Block2 deklariert hat
System.out.println(block2); //Block 2
//Auf Block1 kann zugegriffen werden
System.out.println(block1); //Block 1
}
//Da es außerhalb des Blocks liegt, der Block2 deklariert hat, tritt ein Kompilierungsfehler auf.
System.out.println(block2); // block2 cannot be resolved to a variable
}
}
Das obige ist ein einzelner Block, also ein konkreteres Beispiel ...
** Sie können nicht auf Variablen zugreifen, die in einer anderen Methode als einer anderen Methode deklariert wurden. ** **.
Main.java
class Main {
public static void main(String args[]) {
//Deklarieren und Initialisieren der Variablen block1 in der Hauptmethode
String block1 = "Block 1";
System.out.println(block1); //Block 1
}
public static void method() {
//Diese Methode, die außerhalb des Bereichs liegt, kann nicht auf die Variable block1 zugreifen, was zu einem Kompilierungsfehler führt.
block1 = "Block 3"; // block1 cannot be resolved to a variable
}
}
** Sie können nicht auf die in der if-Anweisung deklarierten Variablen zugreifen. ** **.
Main.java
class Main {
public static void main(String args[]) {
String block1 = "Block 1";
System.out.println(block1); //Block 1
boolean flg = true;
if(flg) {
String block2 = "Block 2";
}
//Da sich die Variable block2 außerhalb des Blocks befindet, weil sie in der if-Anweisung definiert wurde, tritt ein Kompilierungsfehler auf.
block2 = "Ich möchte Block 2 neu schreiben"; // block2 cannot be resolved to a variable
}
In beiden Fällen ist der gültige Bereich von "{} Block Unit" unterschiedlich, sodass kein Zugriff möglich ist und ein Kompilierungsfehler auftritt.
Apropos, Local-Variable Type Inference ist seit JDK 10 verfügbar. Details werden zu einem späteren Zeitpunkt in einem separaten Artikel zusammengefasst, daher werde ich diesmal darauf verzichten.
Eine Variable, die direkt unter der Klassendefinition deklariert ist.
Person.java
class Person {
//Variablen unter Klasse definieren (Instanzvariablen)
String name;
int age;
int height;
//Es kann auch über Methoden innerhalb der Klasse zugegriffen werden (nicht über statische Methoden zugänglich; siehe unten).
public void checkInfo() {
System.out.print("Name ist"+ name + "、");
System.out.print("Alter ist"+ age + "、");
if(age < 20) {
System.out.print("Minderjährig.");
}
System.out.println("Wie groß bist du"+ height + "ist.");
}
}
Wenn mehrere Objekte mit dem neuen Schlüsselwort basierend auf der Person-Klasse erstellt (instanziiert) werden
Der Wert der Instanzvariablen ist für jede Instanz unterschiedlich, und für jedes Objekt können unterschiedliche Werte verarbeitet werden.
Zugriff mit Variablenname, dem das Objekt zugewiesen ist. Name der Instanzvariable.
Main.java
class Main {
public static void main(String args[]) {
Person tanaka = new Person(); //Erstellen Sie ein Objekt mit dem neuen Schlüsselwort
tanaka.name = "Tanaka"; //In dem Variablennamen tanaka, dem das Objekt zugewiesen ist, wird der Wert dem Namen der Instanzvariablen zugewiesen.
tanaka.age = 19; // //Der Wert wird der Instanzvariablen age mit dem Variablennamen tanaka zugewiesen, dem das Objekt zugewiesen ist.
System.out.println(tanaka.name); //Tanaka
System.out.println(tanaka.age); // 19
//↓ Lokale Variablen mussten deklariert und initialisiert werden,
//Instanzvariablen werden automatisch initialisiert.
System.out.println(tanaka.height); // 0
tanaka.checkInfo(); //Der Name ist Tanaka, das Alter ist 19 und er ist minderjährig. Höhe ist 0.
Person suzuki = new Person(); //Erstellen Sie ein Objekt mit dem neuen Schlüsselwort
suzuki.name = "Suzuki"; //Der Wert wird dem Instanzvariablennamen mit dem Variablennamen suzuki zugewiesen, dem das Objekt zugewiesen ist.
suzuki.age = 51; //Der Wert wird der Instanzvariablen age mit dem Variablennamen suzuki zugewiesen, dem das Objekt zugewiesen ist.
suzuki.height = 146; //Der Wert wird der Instanzvariablenhöhe mit dem Variablennamen suzuki zugewiesen, dem das Objekt zugewiesen ist.
System.out.println(suzuki.name); //Suzuki
System.out.println(suzuki.age); // 51
System.out.println(suzuki.height); // 146
suzuki.checkInfo(); //Er heißt Suzuki, ist 51 Jahre alt und 146 Jahre alt.
}
}
Der Zugriff über die statische Methode ist jedoch nicht möglich.
Auf Instanzvariablen wird mit "Objekt zugewiesener Variablenname. Instanzvariablenname" zugegriffen, der instanziiert wird. Sie können nur darauf zugreifen, wenn Sie angeben, um welche Instanz es sich handelt.
Wenn Sie versuchen, ohne Instanziierung darauf zuzugreifen, tritt daher ein Kompilierungsfehler auf.
Person2.java
class Person2 {
//Definieren Sie Variablen unter Klasse
String name;
int age;
//Auch über Methoden in der Klasse zugänglich
public void checkInfo() {
System.out.print("Name ist"+ name + "、");
System.out.print("Alter ist"+ age + "、");
}
//Auf Instanzvariablen kann nicht mit statischen Methoden zugegriffen werden, was zu einem Kompilierungsfehler führt
public static void checkAge() {
if(age < 20) {
System.out.print("Minderjährig."); // Cannot make a static reference to the non-static field age
}
}
}
Wenn die lokale Variable und die Instanzvariable denselben Namen haben, geben Sie mit "this" die Instanzvariable explizit an.
-Definieren Sie ein Argument mit demselben Namen wie die Instanzvariable in der Funktion in der Klasse -Wenn die Instanzvariable und das Argument denselben Namen haben
Person2.java
class Person2 {
//Definieren Sie Variablen unter Klasse
String name;
int age;
public void getName() {
//Wenn kein Argument empfangen wird, kann eine Variable mit demselben Variablennamen wie die Instanzvariable definiert werden.
String name = "getName()Der Name, von dem ich angerufen habe, ist Yamada";
//Anstatt die Instanzvariable auszugeben, wird der in dieser Methode definierte Name bevorzugt ausgegeben.
System.out.println(name);
//Verwenden Sie diese Option, wenn Sie den Namen der Instanzvariablen ausgeben möchten
System.out.println("Der Name der Instanzvariablen lautet" + this.name);
}
public void setAge(int age) {
//Wenn derselbe Variablenname wie die Instanzvariable als Argument empfangen wird,
//Wenn Sie versuchen, mit demselben Variablennamen zu definieren, tritt ein Fehler auf, wenn Duplikate vorhanden sind.
// int age = 101; // Duplicate local variable age
//Verwenden Sie dies wie oben beschrieben, wenn Sie das empfangene Argument der Instanzvariablen zuweisen
this.age = age;
System.out.println("Das Alter der von setAge festgelegten Instanzvariablen beträgt" + age);
}
}
Main2.java
class Main2 {
//Instanzvariable
public static void main(String[] args) {
Person2 sato = new Person2();
sato.name = "Sato";
sato.getName();
// getName()Der Name, von dem ich angerufen habe, ist Yamada
//Der Name der Instanzvariablen wird als Sato ausgegeben
sato.setAge(77);
//Das Alter der von setAge festgelegten Instanzvariablen wird als 77 ausgegeben
}
}
Eine Variable, die direkt unter der Klassendefinition deklariert ist. Wenn eine Variable deklariert wird, wird sie durch Angabe des statischen Modifikators als statische Variable behandelt. Die Instanzvariable enthielt einen Wert für jedes Objekt. Statische Variablen werden an einer Stelle zusammengefasst, um den Wert zu speichern (der gleiche Wert wird für alle Objekte verwendet). ``
** Instanzvariablen sind Variablen für jede Instanz und statische Variablen (Klassenvariablen) sind Variablen für jede Klasse. ** **.
Sample.java
class Sample {
int number = 99; //Instanzvariable
static String color = "Gelb"; //statische Variable (Klassenvariable)
//Eine Methode zum Festlegen eines Werts in einer statischen Variablen (Klassenvariable)
public void setColor(String value) {
color = value;
}
}
Daher kann darauf zugegriffen werden, ohne die Klasse zu instanziieren.
Klassenname.Statische Variable (Klassenvariable) Name
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("rot");
System.out.println(Sample.color); //rot
Sample sample2 = new Sample();
//Da die Zahl, bei der es sich um eine Instanzvariable handelt, für jedes Objekt gespeichert wird, ist der Anfangswert 99 enthalten.
System.out.println(sample2.number); // 99
//statische Variable (Klassenvariable)Weil die Farbe von einen gemeinsamen Wert hat
//Der Standardwert "gelb" ist sample1.Rot wurde zum Zeitpunkt von setColor eingestellt.
//Wenn Sie hier auf die statische Variable (Klassenvariable) zugreifen, wird sie daher rot ausgegeben.
System.out.println(Sample.color); //rot
}
}
Da statische Variablen (Klassenvariablen) allgemeine Variablen der Klasse sind, wirken sich Änderungen auf alle verwendeten Teile aus.
Beispiel) Wenn Sie Daten darüber speichern möchten, wie viele Personen erstellt wurden.
Human.java
class Human {
//Instanzvariable
String name;
//statische Variable(Klassenvariable)
static int count = 0;
//Statische Variablen bei Instanziierung(Klassenvariable)Zu+Ich mache
Human() {
count++;
}
public static void humanCount() {
//Überprüfen Sie, wie viele Personen erstellt wurden
System.out.println(count + "Person erstellt");
}
}
Main.java
class Main {
public static void main(String[] args) {
Human yamada = new Human();
yamada.name = "Yamada";
System.out.println(yamada.name); //Yamada
//Statische Variablen ausgeben (Klassenvariablen)
System.out.println(Human.count); // 1
Human takeda = new Human();
takeda.name = "Takeda";
System.out.println(takeda.name); //Takeda
//Statische Variablen ausgeben (Klassenvariablen)
System.out.println(Human.count); // 2
Human oota = new Human();
oota.name = "Ota";
System.out.println(oota.name); //Ota
//Statische Variablen ausgeben (Klassenvariablen)
System.out.println(Human.count); // 3
Human.humanCount(); //Ausgabe, dass 3 Personen erstellt wurden
}
}
Ich habe den Umfang von Variablen kennengelernt.
** Wenn Sie programmieren, ohne den Umfang zu kennen ... **
・ Fehler kann auftreten
・ Sie können einer Variablen an einer unbeabsichtigten Stelle einen Wert zuweisen (er wurde zugewiesen, obwohl Sie nicht beabsichtigten, ihn zuzuweisen)
Dies kann zu Problemen wie unerwarteten Bewegungen führen.
Ich denke, dass die oben genannten Probleme verhindert werden können, indem sie unter Berücksichtigung des Einflussbereichs des Anwendungsbereichs implementiert werden.
Das nächste Mal werde ich mich mit der Funktionsweise von Zeichenketten befassen (in Vorbereitung).
Recommended Posts