Dieser Artikel ist eine Aufzeichnung dessen, was ich für diejenigen verstehe, die Java studieren.
In meinem Artikel sind die wichtigsten Java-Funktionen in der folgenden Liste zusammengefasst. Dieses Mal wird davon ausgegangen, dass Sie ein gewisses Verständnis für Variablen und Typen haben. Wenn Sie also Fragen haben, überprüfen Sie diese bitte über den unten stehenden Link.
Informationen zur Deklaration, Initialisierung und zum Typ von Java-Variablen Der obige Link ist mein Artikel, den ich zuvor erwähnt habe, aber es gibt andere Dinge zu beachten, wenn Sie innerhalb von Variablen deklarieren und darauf verweisen. In diesem Bereich können Sie die Variablen sehen. Im Folgenden werden lokale und statische Variablen als Beispiele verwendet.
class Main{
public static void main(String args[]){
int i = 30;
System.out.println(i);
}
}
Deklarieren von int i in der Hauptmethode. Sie können es also in main verwenden, bis der Hauptprozess abgeschlossen ist. Wenn du rennst
30
Wird angezeigt, damit der Inhalt von i angezeigt werden kann. Wenn Sie jedoch den zu deklarierenden Ort einschränken, können Sie die Variable möglicherweise nicht finden.
class Main{
public static void main(String args[]){
if(true){
int i = 30; //Erklärt in wenn
}
System.out.println(i);
}
}
Wenn Sie diese Beschreibung ausführen, wird der folgende Fehler angezeigt.
Error:Symbol kann nicht gefunden werden
System.out.println(i);
^
Ich kann ich nicht finden, weil ich es in if deklariere. Ich denke, dass solche Fehler verschwinden werden, wenn wir sie in einem weiten Bereich deklarieren, damit dies nicht geschieht, aber diese Methode hat eine Falle.
class Main{
static int i = 30;
public static void main(String args[]){
System.out.println(i);
plus20();
}
static void plus20(){
i = i + 20;
System.out.println(i);
}
}
Wenn Sie das oben genannte tun,
30
50
Wird sein. Da i überall in der Klasse als verwendbar deklariert ist, können Sie das Innere der Variablen sowohl mit plus20 als auch mit main abrufen. Diese Beschreibung scheint in Ordnung zu sein, aber zum Beispiel ist die plus20-Methode eine Methode, die nur den Status des Hinzufügens von 20 anzeigen möchte. Wenn Sie den ursprünglichen Wert später anzeigen möchten, wird der Wert von i mit plus20 neu geschrieben. Ich werde am Ende.
class Main{
static int i = 30;
public static void main(String args[]){
System.out.println(i);
plus20();
System.out.println(i);
}
static void plus20(){
i = i + 20;
System.out.println(i);
}
}
Wenn du rennst
30
50
50
In der Reihenfolge des Codes möchte ich, dass die dritte Zahl 30 ist, aber da der Wert in plus20 umgeschrieben wurde, ist er 50. Da solche Probleme auftreten, ist es meiner Meinung nach besser, den Variablenbereich so weit wie möglich einzugrenzen.
class Main{
public static void main(String args[]){
int i = 30;
System.out.println(i);
plus20(i);
System.out.println(i);
}
static void plus20(int z){
z = z + 20;
System.out.println(z);
}
}
Wenn du rennst
30
50
30
Selbst wenn ich die Werte in plus20 addierte, störte es i nicht, so dass ich den ursprünglichen Wert von i erhalten konnte.
Jedes hat einen Namen, der vom Referenzbereich der oben genannten Variablen abhängt.
Grundsätzlich handelt es sich um eine Variable, die innerhalb der Methode verwendet wird, und es handelt sich um eine lokale Variable, auf die außerhalb der Methode nicht verwiesen werden kann.
class Main{
public static void main(String args[]){
int i = 100; //von hier
System.out.println(i);
//Bisher
}
}
Grundsätzlich möchte ich den Referenzbereich von Variablen eingrenzen, daher denke ich, dass es einfach ist, dies zu beschreiben.
Schreiben Sie die Deklaration grundsätzlich unter die Klasse und behandeln Sie sie innerhalb der Klasse
class Mikan{
int i;
Mikan(){
this.i = 10;
}
}
Wird für jede Instanz deklariert, wenn Mikan instanziiert wird. Wenn Sie zwei Mikan machen, ist es so, als hätte jeder int i. Mit dieser Definition ist es eine Variable, die innerhalb der Instanz verwendet werden kann. Sie können eine Instanz auch extern erstellen und die Variable lesen.
class Mikan{
int j;
Mikan(){
this.j = 10;
}
}
class Main{
public static void main(String args[]){
Mikan mikan1 = new Mikan();
Mikan mikan2 = new Mikan();
mikan2.j += 10;
//Instanzvariable
System.out.println(mikan1.j);
System.out.println(mikan2.j);
}
}
Wenn Sie es hier ausführen
10
20
Es wird angezeigt. Sie können eine Mikan-Instanz in der Main-Klasse erstellen und auf die darin enthaltenen Variablen verweisen.
Die statische Variable ähnelt der obigen Instanzvariablen, Sie können sie jedoch verwenden, ohne eine Instanz zu erstellen.
class Mikan{
static int i = 10;
}
class Main{
public static void main(String args[]){
System.out.println(Mikan.i);
}
}
10
Es sieht aus wie eine Instanzvariable, hat jedoch bei jeder Erstellung eine Variable. Statische Variablen haben innerhalb der Klasse denselben Wert.
class Mikan{
static int i = 10;
int j;
Mikan(){
this.j = 10;
}
}
class Main{
public static void main(String args[]){
Mikan mikan1 = new Mikan();
Mikan mikan2 = new Mikan();
mikan2.j += 10;
//Instanzvariable
System.out.println(mikan1.j);
System.out.println(mikan2.j);
//statische Variable
System.out.println(Mikan.i);
Mikan.i += 30;
System.out.println(Mikan.i);
}
}
10
20
10
40
Wenn Sie für jede Instanz einen eindeutigen Wert haben möchten, verwenden Sie eine Instanzvariable. Wenn Sie eine Variable gemeinsam sehen möchten, verwenden Sie eine statische Variable.
Wenn Sie eine Instanzvariable oder eine statische Variable von einer Funktion in der Klasse aufrufen, wird dies folgendermaßen beschrieben.
class Mikan{
static int i = 10;
int j = 50;
void inscheck(){
//statische Variablen können aufgerufen werden
System.out.println(i);
//Instanzvariablen können aufgerufen werden
System.out.println(j);
}
static void check(){
//statische Variablen können aufgerufen werden
System.out.println(i);
//Instanzvariablen können nicht aufgerufen werden
// System.out.println(j);
}
}
class Main{
public static void main(String args[]){
Mikan mikan1 = new Mikan();
//Funktionen, die die Instanz hat
mikan1.inscheck();
//statische Funktion
Mikan.check();
}
}
Wenn du rennst
10
50
10
Es wird sein. Beide können über die Funktion der von der Instanz aufgerufenen Instanz aufgerufen werden.
Im Fall einer statischen Funktion, die von einer Klasse aufgerufen wird, können statische Variablen aufgerufen werden, Instanzvariablen jedoch nicht.
Wenn Sie auskommentieren und kompilieren
test.java:18:Error:Die nicht statische Variable j kann nicht aus dem statischen Kontext referenziert werden
System.out.println(j);
^
1 Fehler
Ich werde herauskommen. Wenn Sie einen solchen Fehler erhalten, können Sie ihn schnell beheben, indem Sie den Modifikator der Variablenspezifikation überprüfen.
Es war eine Erklärung für den Bereich, in dem Variablen sichtbar sind. Mit dem Fortschreiten des Verständnisses dieses Bereichs denke ich, dass es weniger Fehler geben wird, wie z. B. unbeabsichtigte Werte.
Recommended Posts