In diesem Artikel wird der Unterschied zwischen Mitgliedsvariablen und lokalen Variablen in Java anhand von Beispielen analysiert. Teilen Sie es als Referenz mit allen. Die spezifische Analyse lautet wie folgt:
Mitgliedsvariablen: In dieser Klasse definierte private Variablen gehören zu dieser Klasse.
Erstellen und verwenden Sie Mitgliedsvariablen, um den Code zu kopieren. Der Code lautet wie folgt: öffentliche Klasse Person {.
Stringname;
String-Sex;
int Alter;
doppelte Höhe;
public static void main(String arges[])
{
Person p=neue Person();
p.name="Xiao Huang";
p.Sex="Männlich";
S.Alter=20;
p.Höhe=1,7;
System.out.println("Name:"+p.name+",Gender"+p.Sex+",Age:"+p.age+",Age:"+p.Height);
}
}
Initialisierungsprozess der Mitgliedsvariablen
1. Initialisierung der Klasse
Für die Klasseninitialisierung: Die Klasseninitialisierung wird im Allgemeinen nur einmal initialisiert, und die Klasseninitialisierung initialisiert hauptsächlich statische Mitgliedsvariablen.
Die Kompilierung einer Klasse bestimmt den Initialisierungsprozess der Klasse.
Die vom Compiler generierte Klassendatei nimmt hauptsächlich die folgenden Änderungen an den in der Quelldatei definierten Klassen vor:
1) Deklarieren Sie zunächst Mitgliedsvariablen innerhalb der Klasse in der Reihenfolge, in der statische Mitgliedsvariablen definiert werden.
2) Initialisieren Sie gemäß der Initialisierungssequenz der Mitgliedsvariablen in der ursprünglichen Java-Klasse.
Die entsprechende Konvertierung zwischen einer Java-Klasse und der kompilierten Klasse lautet wie folgt:
Quelldatei:
Kopieren Sie den Code wie folgt: public class Person{
public static String name="Zhang San";
öffentliches statisches Int-Alter;
statisch{
Alter=20;
System.out.println("Initialisierungsalter");
}
öffentliche statische String-Adresse;
statisch{
Adresse="Peking";
Alter=34;
}
public static void main(String[] args) {
System.out.println(name);
System.out.println(age);
System.out.println(address);
}
}
Wenn der Java-Quellcode in eine Klassendatei konvertiert wird, wird er in einen Code ähnlich dem folgenden umgewandelt:
Kopieren Sie den Code wie folgt: public class Person{
öffentlicher statischer String-Name;
öffentliches statisches Int-Alter;
öffentliche statische String-Adresse;
statisch{
name="Zhang San";
Alter=20;
System.out.println("Initialisierungsalter");
Adresse="Peking";
Alter=34;
}
public static void main(String[] args) {
System.out.println(name);
System.out.println(age);
System.out.println(address);
}
}
Die Initialisierungssequenz wird sequentiell entsprechend der Initialisierungssequenz der entsprechenden Klassenmitgliedsvariablen nach der Konvertierung ausgeführt, sodass alle statischen Mitgliedsvariablen zuerst deklariert und dann zugewiesen werden und die Reihenfolge der Zuweisung auch auf der Reihenfolge der statischen Mitgliedsvariablen basiert Im Quellcode initialisiert. Hinweis: Das Definieren und Initialisieren einer Mitgliedsvariablen entspricht dem Initialisieren in einem statischen Codeblock, beides in der Reihenfolge, in der sie im Quellcode definiert sind.
lokale Variablen
Lokale Variable: Diese Variable wird im Methodenkörper erstellt und kann außerhalb des Methodenkörpers nicht aufgerufen werden.
Erstellung und Verwendung lokaler Variablen (lokalen Variablen muss ein Wert zugewiesen werden, Mitgliedsvariablen darf kein Wert zugewiesen werden)
Kopieren Sie den Code wie folgt: public class Person {
public static void main(String arges[])
{
String name="Xiao Huang";
String Sex="Männlich";
int Alter=20;
doppelte Höhe=1,70;
System.out.println("Name:"+name+",gender"+Sex+",age:"+age+",age:"+Height);
}
}
Sehen Sie sich das Beispiel an und kopieren Sie den Code. Der Code lautet wie folgt: öffentliche Klasse PassTest {
public static void main(String args[]) {
StringBuffer a = new StringBuffer("a");
StringBuffer b = new StringBuffer("b");
a(a, b);
System.out.println(a);
System.out.println(b);
PassTest p = new PassTest();
pc();
}
static void a(StringBuffer a, StringBuffer b) {
a = a.append(b);
b = a;
}
}
Je nach Verwendungsbereich lokaler Variablen sollte das Ergebnis ab sein, aber tatsächlich ist die Ausgabe tatsächlich ab b.
Es handelt sich um die Übergabe von Parameterreferenzen. Wenn es sich um eine Referenz handelt, sollte eine Kopie derselben Referenz übergeben werden.
b=a in Methode a ändert die Kopie-b-Referenz in =a, hat aber keine Auswirkung auf b in main.
a = a.append(b); Hauptsächlich a.append(b); Dieser Satz ändert den Wert, auf den eine Referenz zeigt, da a in main auch auf dasselbe Objekt zeigt, sodass die Ausgabe ab b ist
Wenn a = a.append(b); in a = new StringBuffer("ab"); geändert wird, wird ab ausgegeben
Schauen Sie sich die folgenden zwei Programme an:
Verfahren eins:
Kopieren Sie den Code wie folgt: public class Variable
{
int i;
void test()
{
int j=8;
if(j==i)
System.out.println("Gleich");
anders
System.out.println("Nicht gleich");
}
public static void main(String[] args)
{
Variable v=neue Variable();
v.test();
}
}
Verfahren zwei:
Kopieren Sie den Code wie folgt: public class Variable
{
void test()
{
int i;
int j=8;
if(j==i)
System.out.println("Gleich");
anders
System.out.println("Nicht gleich");
}
public static void main(String[] args)
{
Variable v=neue Variable();
v.test();
}
}
Das erste Programm ist normal und wird ohne Fehler kompiliert. Wenn das zweite Programm kompiliert wird, wird die folgende Fehlermeldung angezeigt:
D:Programjavatest>javac Variable.java
Variable.java:9: Variable i wurde möglicherweise noch nicht initialisiert
if(j==i)
^
Fehler
Der Grund, warum ein solcher Fehler auftritt, liegt darin, dass Mitgliedsvariablen Standardwerte haben (die durch final und nicht statisch geänderten Werte müssen explizit zugewiesen werden) und lokale Variablen werden nicht automatisch zugewiesen.
Der Klassenkörper ist in zwei Teile gegliedert. Die im Variablendefinitionsteil definierten Variablen werden als Mitgliedsvariablen der Klasse bezeichnet, und die im Methodenkörper definierten Variablen und die Parameter der Methode werden als lokale Variablen bezeichnet.
Der Unterschied zwischen lokalen Variablen und Mitgliedsvariablen
Lokale Variablen beschreiben die Attribute im Methodenkörper, während Mitgliedsvariablen die Attribute im Objekt beschreiben.
Mitgliedsvariablen können durch öffentliche, geschützte, Standard-, private, statische und endgültige Modifikatoren geändert werden, während lokale Variablen nur durch den endgültigen Modifikator geändert werden können.
Mitgliedsvariablen werden auf dem Heap und lokale Variablen auf dem Stapel erstellt.
Lokale Variablen haben Systemstandardwerte und müssen manuell zugewiesen werden.
Ich hoffe, dass dieser Artikel für die Java-Programmierung aller hilfreich sein wird.