Java-Zusammenfassung für reservierte Wörter

Java reservierte Wortzusammenfassung

Inhaltsverzeichnis

• Was ist ein reserviertes Wort?
• Liste der reservierten Wörter
• Erklärung jedes reservierten Wortes

Was ist ein reserviertes Wort?

• Ein Wort, dessen Zweck in einer Programmiersprache vorgegeben ist. Grundsätzlich können Bezeichner (Klassenname, Funktionsname, Variablenname) frei festgelegt werden, aber der gleiche Name wie das reservierte Wort kann nicht verwendet werden.

Liste der reservierten Wörter

Beschreibung jedes reservierten Wortes

abstract

• Wird beim Deklarieren einer abstrakten Klasse verwendet.
• Eine abstrakte Klasse ist eine Klasse mit den folgenden leeren Methoden.

Name der abstrakten Methode(Streit, Streit, ...);

Wann zu verwenden

• Wenn Sie bei der Entwicklung mit mehreren Personen Regeln auf Implementierungsebene erstellen möchten.
• Wenn Sie die Methodennamen vereinheitlichen möchten, standardisieren Sie die Logik und verstehen Sie, was Sie tun.
• Wenn Sie nicht jedes Mal eine gemeinsame Verarbeitung für alle Klassen schreiben möchten.
• Wenn der Entwickler eine Unterklasse definiert und überprüfen möchte, ob die Methode vergessen wurde oder der Methodenname korrekt ist.

Beispielcode

abstract class AbstractClass {
  abstract public void method();
}

class ConcreteClass extends AbstractClass{
  public void method(){
    //Implementierungsdetails
  }
}

AbstractClass c = new AbstractClass(); //Kompilierungsfehler
AbstractClass c = new ConcreteClass(); //Ja
ConcreteClass c = new ConcreteClass(); //Ja

assert

• abstract: Wird verwendet, wenn eine abstrakte Klasse deklariert wird
• assert: Wird zur Überprüfung des Programmbetriebs (Assertion) verwendet.
• Behauptung (Betriebsüberprüfung): Eine Methode zur Überprüfung, ob ein Programm normal funktioniert. Wenn Sie eine Bedingung deklarieren, die zu diesem Zeitpunkt in verschiedenen Teilen des Programms immer wahr ist, erkennt Java automatisch, dass die Bedingung zur Laufzeit nicht erfüllt ist, und ein AssertionError wird zurückgegeben.
• Sie können Zusicherungen aktivieren oder deaktivieren, indem Sie zur Laufzeit die Option -enebleassertions (oder -ea) übergeben.

Wann zu verwenden

• Wenn Sie Debugging-Unterstützung bereitstellen möchten.
• Wenn Sie die Absicht des Entwicklers im Quellcode des Programms beschreiben möchten.

Beispielcode

private int divide(int x, int y) {
    assert y != 0 : y +"Muss eine Zahl größer als 0 sein";

    return x / y;
}

boolean

• Ein Datentyp, der angibt, dass entweder wahre oder falsche Daten enthalten sein müssen.
• Wenn als Instanzvariable deklariert, wird false als Anfangswert eingegeben. Wenn es jedoch als lokale Variable deklariert wird, wird der Anfangswert nicht festgelegt, sodass er festgelegt werden muss.
• Instanzvariable: In der Klasse deklarierte Variable
• Lokale Variable: In der Methode deklarierte Variable
• Es gibt auch einen Booleschen Wert, der als Klasse verwendet wird. Während Boolean nicht null ausdrücken kann, kann Boolean null verarbeiten. Wenn die Variable jedoch nicht auf null gesetzt ist, tritt eine NullPointerException auf.

Wann zu verwenden

• Beim Ausdrücken des Vergleichsergebnisses von numerischen Werten und Zeichenfolgen.
• Wenn die if-Anweisung die Verzweigungsrichtung angibt.
• Bei der Entscheidung, ob die Schleife mit einer for-Anweisung oder einer while-Anweisung fortgesetzt werden soll.

Beispielcode

//Im Falle einer if-Anweisung
public class Main {
    public static void main(String[] args) throws Exception {
        boolean bool1 = false;
        
        if(bool1) {
          System.out.println("Der Wert von bool1 ist wahr");            
        } else {
          System.out.println("Der Wert von bool1 ist false");
        }
        
        int number = 100;
        
        boolean isResult = number < 200;
        
        if(isResult) {
          System.out.println("Der Wert von isResult ist wahr");            
        } else {
          System.out.println("Der Wert von isResult ist false");    
        }
 
    }
}
//Ausführungsergebnis
Der Wert von bool1 ist false
Der Wert von isResult ist wahr

//Für while-Anweisung
public class Main {
    public static void main(String[] args) throws Exception {
        boolean bool = true;　//Anfangswerteinstellung
        int count = 1; //Anfangswerteinstellung
        
        while(bool) {
            System.out.println("Der Wert von count ist" + count + "ist.");  
            if(count == 5) {
                bool = false; //Verarbeitung, die ausgeführt werden soll, wenn der Wert von count 5 erreicht.
            }
            count++; //Addiere 1 zum Wert der Variablen "count".
        }
 
    }
}
//Ausführungsergebnis
Der Wert von count ist 1.
Der Wert von count ist 2.
Der Wert von count ist 3.
Der Wert von count ist 4.
Der Wert von count ist 5.

//Für booleschen Typ
public class Main {
    public static void main(String[] args) throws Exception {
        Boolean bool = null;
        
        if(bool == null) {
            System.out.println("Der Wert von bool ist null");
        } else if(bool) {
            System.out.println("Der Wert von bool ist wahr");
        } else {
            System.out.println("Der Wert von bool ist false");            
        }
 
    }
}
//Ausführungsergebnis
Der Wert von bool ist null

break

• Die break-Anweisung ist eine Syntax, die in Blöcken von for, while, do..while und switch-Anweisungen verwendet wird, um während der Verarbeitung auszubrechen. Verlasse die innerste Schleife (sich wiederholender Prozess). Fügen Sie beim Beenden einer Doppelschleife der ersten for-Anweisung eine Bezeichnung (wie einen Namen) hinzu und geben Sie diese Bezeichnung an, wenn Sie mit break beenden.

Wann zu verwenden

• Wenn Sie den Prozess beenden und den nächsten Prozess unter bestimmten Bedingungen ausführen möchten.

Beispielcode

//Für die switch-Anweisung
public static void main(String[] args) {
  int num = 3;
  switch(num) {
    case 1:
      System.out.println("Es ist 1");
      break;
    case 2:
      System.out.println("Es ist 2");
      break;
    case 3:
      System.out.println("Es ist 3");
      break;
    case 4:
      System.out.println("Es ist 4");
      break;
    default:
      System.out.println("Es ist Standard");
  }
}
//Ausführungsergebnis
Es ist 3

//Zur Aussage
public static void main(String[] args) {
  for (int i = 1; i <= 5; i++) {
    if (i == 3) {
      break;
    }
    System.out.println(i + "Zeit");
  }
  System.out.println("Es ist fertig");
}
//Ausführungsergebnis
Erstes Mal
Zweites Mal
Es ist fertig

//Für while-Anweisung
public static void main(String[] args) {
  int num = 1;
  while(true) {
    if (num == 3) {
      break;
    }
    System.out.println(num + "Dies ist das zweite Mal");
    num++;
  }
  System.out.println("Es ist fertig");
}
//Ausführungsergebnis
Es ist das erste Mal
Es ist das zweite Mal
Es ist fertig

//Für Doppelschleife
loop1: for(Initialisierungsformel;Bedingter Ausdruck;Formel ändern){//Geben Sie den Namen der for-Anweisung in loop1 an
        for(Initialisierungsformel;Bedingter Ausdruck;Formel ändern){
                if(Bedingter Ausdruck beim Verlassen der for-Schleife) break loop1;//Geben Sie den Exit für die Anweisung in loop1 an

Inhalte verarbeiten
        }
}
//Ausführungsergebnis
Wenn die Bedingung erfüllt ist, beenden Sie den Prozess loop1

byte

• Einer der ganzzahligen Datentypen, die als Grundelemente bezeichnet werden.
• Kann ganze Zahlen von -128 bis 127 darstellen.

Wann zu verwenden

• Beim Umgang mit Binärdateien und Binärdaten "wie sie sind".
• Binärdatei: Eine Datei mit Binärdaten. Von diesen werden diejenigen, die vom Texteditor verarbeitet werden können, als Textdateien klassifiziert.
• Binärdaten: In Binärdaten ausgedrückte Daten zur direkten Verarbeitung durch den Computer.
• Die Daten, die während des Streamings beim Ansehen eines Videos vom Server gesendet werden, sind Binärdaten.
• Wird häufig verwendet, um eine Sammlung von Binärdaten in einem Array und nicht als einzelne Variable darzustellen.

Beispielcode

//Deklaration der Bytetypvariablen und Zuweisung des Anfangswertes
byte b = 100;
 
//Deklaration des Bytetyp-Arrays und Zuweisung des Werts zu jedem Index
byte[] byteArray1 = new byte[3];
byteArray1[0] = 11;
byteArray1[1] = 12;
byteArray1[2] = 13;
 
//Deklaration des Bytetyp-Arrays und Initialisierung gleichzeitig
byte[] byteArray2 = { -128, 0, 127 };

switch

• Reservierte Wörter für die bedingte Verzweigungsverarbeitung.

Wann zu verwenden

• Wird verwendet, wenn mehrere bedingte Verzweigungsziele vorhanden sind.

Beispielcode

public class Main {
  public static void main(String[] args) {
    int num = 3;
    switch(num) {
    case 1:
      System.out.println("Die Variable num ist 1");
      break;
    case 2:
      System.out.println("Die Variable num ist 2");
      break;
    case 3:
      System.out.println("Die Variable num ist 3");
      break;
    case 4:
      System.out.println("Die Variable num ist 4");
      break;
    default:
      System.out.println("Die Variable num ist keine Ganzzahl von 1 bis 4");
    }
  }
}
//Ausführungsergebnis
Die Variable num ist 3

case

• Ein reserviertes Wort, das verwendet wird, wenn eine bedingte Verzweigungsverarbeitung in einer switch-Anweisung ausgeführt wird.

Wann zu verwenden

• Wird verwendet, um das bedingte Verzweigungsziel der switch-Anweisung zu beschreiben.

Beispielcode

public class Main {
  public static void main(String[] args) {
    int num = 3;
    switch(num) {
    case 1:
      System.out.println("Die Variable num ist 1");
      break;
    case 2:
      System.out.println("Die Variable num ist 2");
      break;
    case 3:
      System.out.println("Die Variable num ist 3");
      break;
    case 4:
      System.out.println("Die Variable num ist 4");
      break;
    default:
      System.out.println("Die Variable num ist keine Ganzzahl von 1 bis 4");
    }
  }
}
//Ausführungsergebnis
Die Variable num ist 3

default

• Ein reserviertes Wort für die Verarbeitung, wenn die Bedingung in der switch-Anweisung nicht erfüllt ist.
• Ein reserviertes Wort für die Implementierung einer Methode in der Schnittstelle.

Wann zu verwenden

• Wird verwendet, wenn die Verarbeitung ausgeführt wird, wenn die Bedingung in der switch-Anweisung nicht erfüllt ist.
• Wenn die Schnittstelle Methoden haben soll.

Beispielcode

public class Main {
  public static void main(String[] args) {
    int num = 5;
    switch(num) {
    case 1:
      System.out.println("Die Variable num ist 1");
      break;
    case 2:
      System.out.println("Die Variable num ist 2");
      break;
    case 3:
      System.out.println("Die Variable num ist 3");
      break;
    case 4:
      System.out.println("Die Variable num ist 4");
      break;
    default:
      System.out.println("Die Variable num ist keine Ganzzahl von 1 bis 4");
    }
  }
}
//Ausführungsergebnis
Die Variable num ist keine Ganzzahl von 1 bis 4

//Für die Schnittstelle
interface Foo{
    void print(String s);
    default void twice(String s){
        print(s);
        print(s);
    }
}

try

• Reservierte Wörter für die Verarbeitung, die Ausnahmen verursachen können.

Wann zu verwenden

• Wird verwendet, um die Verarbeitung zu beschreiben, die eine Ausnahme verursachen kann, wenn Sie die Verarbeitung ausführen möchten, wenn eine Ausnahme auftritt.
• Wenn Sie die Ursache verstehen möchten, wenn während der Verarbeitung ein Problem auftritt.

Beispielcode

public class Main {
 
    public static void main(String[] args) {
        int result;
        result = div(5, 0);
        System.out.println("Rückgabewert= " + result);
    }
 
    public static int div(int num1, int num2) {
        try {
            int result = num1 / num2;
            
            return result;
 
        } catch (ArithmeticException e) {
            System.out.println("Ausnahme aufgetreten.");
            System.out.println(e);
 
            return 0;
        }
    }
 
}

catch

• Ein reserviertes Wort für die Verarbeitung, wenn eine Ausnahme auftritt.
• Beschreiben Sie wie folgt.

catch(Name der Ausnahmeklassenvariablen) {
Ausnahmebehandlung;
}

• Ausnahmeklasse: Es gibt Folgendes.
• Throwable
  • Error
• Fehlerausnahmen * OutOfMemoryError * ClassFormatError ...etc.
  • Excption
• Ausnahme Typ Ausnahme * IOException * ConnectException ...etc.
• RuntimeException * NullPointException * ArrayIndexOUtOFBOUndsExeception ...etc.

Wann zu verwenden

• Wenn es einen Prozess gibt, der eine Ausnahme verursachen kann, wird er verwendet, um den Prozess zu beschreiben, den Sie ausführen möchten, wenn tatsächlich eine Ausnahme auftritt.

Beispielcode

public class Main {
 
    public static void main(String[] args) {
        int result;
        result = div(5, 0);
        System.out.println("Rückgabewert= " + result);
    }
 
    public static int div(int num1, int num2) {
        try {
            int result = num1 / num2;
            
            return result;
 
        } catch (ArithmeticException e) {
            System.out.println("Ausnahme aufgetreten.");
            System.out.println(e);
 
            return 0;
        }
    }
 
}
//Ausführungsergebnis
Ausnahme aufgetreten.
java.lang.ArithmeticException: / by zero
Rückgabewert= 0

finally

• Ein reserviertes Wort, das den auszuführenden Prozess deklariert, unabhängig davon, ob eine Ausnahme auftritt.

Wann zu verwenden

• Wird verwendet, um den Prozess zu beschreiben, den Sie ausführen möchten, wenn es einen Prozess gibt, der wahrscheinlich eine Ausnahme verursacht, unabhängig davon, ob eine Ausnahme auftritt oder nicht.

Beispielcode

int n[] = {18, 29, 36};

System.out.println("Start");

try{
  for (int i = 0; i < 4; i++){
    System.out.println(n[i]);
  }
}
catch(ArrayIndexOutOfBoundsException e){
  System.out.println("Über den Bereich des Arrays hinaus");
}
finally{
  System.out.println("Ausgabe des Arrays beendet");
}

System.out.println("Fertig");

throw

• Ein reserviertes Wort zum absichtlichen Auslösen einer Ausnahme und zum Behandeln der Ausnahme.
• Absichtlich eine Ausnahme auslösen: Eine Ausnahme auslösen und eine Fehlermeldung zurückgeben, wenn eine bestimmte Bedingung erfüllt ist.

Wann zu verwenden

• Wird verwendet, wenn Sie bei der Verarbeitung eine Ausnahme auslösen möchten.

Beispielcode

public class Main {
 
    public static void main(String[] args) {
        int result;
        result = div(5, 0);
        System.out.println("Rückgabewert= " + result);
    }
 
    public static int div(int num1, int num2) {
        try {
            if (num2 == 0) {
                throw new ArithmeticException("Lösen Sie eine Ausnahme aus, wenn Sie durch 0 geteilt werden");
            }
            int result = num1 / num2;
 
            return result;
 
        } catch (Exception e) {
            System.out.println("Ausnahme aufgetreten.");
            System.out.println(e);
 
            return 0;
        }
    }
 
}
//Ausführungsergebnis
Ausnahme aufgetreten.
java.lang.ArithmeticException:Lösen Sie eine Ausnahme aus, wenn Sie durch 0 geteilt werden
Rückgabewert= 0

throws

• Ein reservierter Begriff, mit dem der Anrufer die Ausnahme behandeln kann, wenn eine Ausnahme auftritt.
• Anrufer: Im folgenden Code ruft main die mathematische Methode auf, also ist main der Anrufer und math der Angerufene.

public static void main(String[] args) {
    int num = 10;

    math(num);

    math(int i) {
        int i += 100;
    }
}

Wann zu verwenden

• Wird verwendet, wenn Sie das Auftreten von Ausnahmen der aufgerufenen Methode in der aufrufenden Methode behandeln möchten.
• Sie können die Lesbarkeit verbessern, indem Sie verschiedene Methoden mit der Hauptmethode aufrufen und dort Ausnahmen behandeln.

Beispielcode

public class Main {
 
    public static void main(String[] args) {
        int result = 0;
        try {
            result = div(5, 0);
        } catch (Exception e) {
            System.out.println("Ausnahme aufgetreten.");
            System.out.println(e);
        }
 
        System.out.println("Rückgabewert= " + result);
    }
 
    public static int div(int num1, int num2) throws ArithmeticException {
        int result = num1 / num2;
 
        return result;
    }
 
}
//Ausführungsergebnis
Ausnahme aufgetreten.
java.lang.ArithmeticException: / by zero
Rückgabewert= 0

for

• Reservierte Wörter, die iterative Prozesse erzeugen können.

for(Initialisierungsformel;Bedingter Ausdruck;Formel ändern){
Auszuführender Prozess
}

• Es gibt auch eine erweiterte for-Anweisung, die wie folgt beschrieben wird.

for (Geben Sie den Variablennamen ein:Array-Name oder Sammlungsname){
Auszuführender Prozess
}

Wann zu verwenden

• Wird verwendet, wenn die Verarbeitung wiederholt wird.

Beispielcode

public class sample {
    public static void main (String[] args){
        int sum = 0;//[1]
        for (int number = 1; number <= 10; number++) {//[2]
            sum += number;//[3]
        }
        System.out.println("sum:" + sum);//[4]
    }
}
//Ausführungsergebnis
sum:55

continue

• Ein reserviertes Wort, um den Rest der Verarbeitung zu überspringen, z. B. für Anweisung und while-Anweisung, und um zum Beginn der Wiederholung zurückzukehren.

Wann zu verwenden

• Wird verwendet, wenn Sie den Rest des Prozesses überspringen und unter bestimmten Bedingungen zum Beginn des iterativen Prozesses zurückkehren möchten, wenn Sie den iterativen Prozess ausführen.
• Kann nur in der iterativen Verarbeitung verwendet werden.

Beispielcode

class sample{
    public static void main(String args[]){
  
      for (int i = 1; i < 10; i++){
        if (i % 2 == 0){//In diesem Fall nur, wenn der Wert von i gerade ist(1)Wird übersprungen
          continue;
        }
  
        System.out.println("i = " + i);//(1)
      }
    }
  }
//Ausführungsergebnis
i = 1
i = 3
i = 5
i = 7
i = 9

if

• Reserviertes Wort für bedingte Verzweigung.

Wann zu verwenden

• Es gibt 6 Möglichkeiten, es zu verwenden.
• 1. Beschreibungsmethode, wenn die if-else-Anweisung mehrere Bedingungen enthält
• 2. Verwendung von Vergleichsoperatoren (gleich und ungleich)
• 3. Verwendung logischer Operatoren (ODER / UND / NICHT)
• 4. Beschreibungsmethode, bei der die if-else-Anweisung in einer Zeile mit dem ternären Operator weggelassen wird
• 5. So überprüfen Sie, ob die Zeichenfolge mit (gleich) übereinstimmt / die Zeichenfolge enthält
• 6. So steuern Sie die Schleife mit Pause oder fahren fort

Beispielcode

//Im Falle von 1
public class Main{
  public static void main(String[] args){
    int number = 80;
 
    if (number > 90) {
      System.out.println("Tolles Ergebnis!");
    } else if (number > 60) {
      System.out.println("Es ist ein gutes Ergebnis.");
    } else {
      System.out.println("Geben wir unser Bestes.");
    }
  }
}
//Ausführungsergebnis
Es ist ein gutes Ergebnis.

//Im Falle von 2
public class Main{
  public static void main(String[] args){
    int number = 10;
    if (number < 20) {
      System.out.println(number + "Ist weniger als 20");
    }
  }
}
//Ausführungsergebnis
10 ist weniger als 20

//Im Falle von 3
public class Main{
  public static void main(String[] args){
    int number = 10;
 
    if ((number < 20) || (number >= 10)) {
      System.out.println(number + "Ist ein Wert größer oder gleich 10 oder kleiner als 20");
    }
  }
}
//Ausführungsergebnis
10 ist ein Wert größer oder gleich 10 oder kleiner als 20

//Im Falle von 4
public class Main {
    public static void main(String[] args) {
 
        int number = 10;
        String str = (number == 5) ? "Nummer ist 5" : "Nummer ist nicht 5";
        System.out.println(str);
    }
}
//Ausführungsergebnis
Nummer ist nicht 5

//Im Falle von 5
public class Main {
    public static void main(String[] args) {
 
        String str1 = "Topfbrot";
        if(str1 == "Topfbrot") {
          System.out.println("str1 entspricht der Zeichenfolge "potepan"");
        } else {
          System.out.println("str1 stimmt nicht mit der Zeichenfolge "potepan" überein");
        }
    }
}
//Effektives Ergebnis
str1 entspricht der Zeichenfolge "potepan"

else

• Ein reserviertes Wort für die Verarbeitung, wenn die Bedingung falsch ist, wenn eine bedingte Verzweigung mit der if-Anweisung durchgeführt wird.

Wann zu verwenden

• Wird verwendet, um die Verarbeitung zu beschreiben, wenn die Bedingung in der if-Anweisung nicht erfüllt ist.

Beispielcode

class sample {
    public static void main (String[] args){
        int number = 200;//[1]
        if (number >= 1 && number <= 9){//[2]
            System.out.println("[3] number : 1 - 9");
        } else if (number >= 10 && number <= 99) {//[4]
            System.out.println("[5] number : 10 - 99");
        } else {//[6]
            System.out.println("[7] number >= 100");
        }
    }
}
//Ausführungsergebnis
[7] number >= 100

char

• Ein Typ, der ein Zeichen speichern kann.
• Verwenden Sie den in 16-Bit-Unicode ausgedrückten.
• 16-Bit-Unicode: Zeichen von 0 bis 65535.

Wann zu verwenden

• Wird beim Speichern eines Zeichens verwendet.

Beispielcode

class sample {
    public static void main(String[] args) {
        char  chrHensu1 = 'A';      //Ersetzen Sie A so wie es ist
        char  chrHensu2 = 0x0041;   //Geben Sie 0x0041 an
        char  chrHensu3 = 65;       //Geben Sie 65 an
         
        System.out.println(chrHensu1);
        System.out.println(chrHensu2);
        System.out.println(chrHensu3);
    }
}
//Ausführungsergebnis
A
A
A

class

• Ein reserviertes Wort, das eine Klasse deklariert.

Wann zu verwenden

• Wird beim Deklarieren einer Klasse verwendet.

Beispielcode

Klasse Klassenname{
Ausführungsverarbeitung...
}

const

• Ungültiges reserviertes Wort.
• Ein reserviertes Wort, das in C / c ++ - Sprachen "konstant" bedeutet.
• In Java entspricht es "final".

Wann zu verwenden

• Da es sich um ein reserviertes Wort handelt, kann es nicht für Variablennamen, Funktionsnamen und Klassennamen verwendet werden.

Beispielcode

• Keiner

do

• Reservierte Wörter, die mit while-Anweisungen verwendet werden.

Wann zu verwenden

• Bei der iterativen Verarbeitung wird die Auswertung des ersten bedingten Ausdrucks normalerweise durchgeführt, bevor die iterative Verarbeitung gestartet wird. In einigen Fällen kann der nächste Prozess ausgeführt werden, ohne auch nur einmal verarbeitet zu werden.
• Wird verwendet, wenn Sie die while-Anweisung nur einmal verarbeiten möchten, damit diese Situation nicht auftritt.

Beispielcode

public class sample {
    public static void main(String[] args) {
        int i = 0;
        do {
            System.out.println((i + 1) + "Dies ist der zweite Prozess");
            i++;
        } while (i < 3);
        System.out.println("Die Verarbeitung ist beendet");
    }
}
//Ausführungsergebnis
Dies ist der erste Prozess
Dies ist der zweite Prozess
Dies ist der dritte Prozess
Die Verarbeitung ist beendet

double

• Einer der Datentypen, der eine kleine Anzahl verarbeiten kann.
• Es gibt auch eine Klasse Double, die auch null darstellen kann.
• Kann als null ausgedrückt werden, wenn die zugewiesene Nummer einen Fehler enthält und kein Wert vorhanden ist.

Wann zu verwenden

• Wird verwendet, wenn große Zahlen im Bereich von 10 ^ 303 bis 10 ^ -324 verarbeitet werden.
• Es gibt folgende Möglichkeiten, Zahlen zu schreiben, die Doppelvariablen zugewiesen werden können.
• Ablehnen (Ganzzahl, Bruch)
• Ablehnen + Exponentialschreibweise
• Binär (ab 0b, Ganzzahl), Java 7 oder höher
• 8 Basiszahlen (beginnend mit 0, Ganzzahl)
• Sechseck (beginnend mit 0x, Ganzzahl)
• Sechseck + Exponentialschreibweise

Beispielcode

//Zahlen mit Dezimalstellen in Dezimalzahlen und Ganzzahlen in Binär-, Oktal- und Hexadezimalzahlen
double d1 = 12345; //Dezimalzahl(ganze Zahl)
double d2 = 1.2345; //Dezimalzahl(Es gibt einen Dezimalpunkt)
double d3 = -123_456.789_012; //Dezimalzahl mit Trennzeichen
double d4 = 0b0101; //Binäre Ganzzahl
double d5 = 012345; //Acht Ganzzahlen
double d6 = 0x12345; //Sechseckige ganze Zahl

//Exponentielle Notation für Dezimal- und Hexadezimalzahlen
double d1 = 1.23e4; //Dezimale Exponentialschreibweise(1.23 × 10 4) → 12300
double d2 = -1.23e-4; //Dezimale Exponentialschreibweise(-1.23x10-4. Potenz) → -0.000123
double d3 = 0x1.23p4; //Hexagonale Exponentennotation(0x1.23 x 2 nach der 4. Potenz) → 18.1875
double d4 = -0x1.23p-4; //Hexagonale Exponentennotation(-0x1.23x2-4. Potenz) → -0.071044921875

//D als Suffix/Wenn Sie D hinzufügen, wird das Literal als doppelt behandelt.
double d1 = 5 / 10; //→ 0, int 5 wird durch int 10 geteilt, sodass das Berechnungsergebnis int 0 ist
double d2 = 5 / 10d; // → 0.Da 5 von 5 und int durch 10 von double geteilt werden, wird 5 ebenfalls double und das Berechnungsergebnis ist 0 von double..Werden Sie 5

enum

• Ein Typ, der mehrere Konstanten zu einer kombinieren kann.
• Da es sich um eine Klasse handelt, können Sie Felder und Methoden definieren.
• wichtiger Punkt
• Sie können dem Enumerator der Enum-Klasse Werte zuweisen. In diesem Fall müssen Sie Felder und Konstruktoren definieren.
• Im Enum-Klassenkonstruktor sind nur Modifikatoren für den privaten Zugriff zulässig.
• Die Enum-Klasse kann nicht von einer anderen Klasse erben, aber eine Schnittstelle implementieren.
• Beschreiben und verwenden Sie wie folgt.

Name der Enum-Aufzählung des Zugriffsmodifikators{Enumerator 1,Enumerator 2,・ ・ ・};

Wann zu verwenden

• Wird verwendet, wenn Sie einen festen Wert verarbeiten möchten.
• Weil Sie die Konstante beschreiben können, die Sie in enum festgelegt haben, und Sie können den Prozess für diesen Wert mit einer switch-Anweisung oder dergleichen beschreiben.

Beispielcode

Bei Verwendung der switch-Anweisung
public class Main {
 
    public static void main(String[] args) {
        Fruit fruit_type = Fruit.Orange;
        
        switch(fruit_type) {
            case Orange:
                System.out.println("Leckere Orangen");
                break;
            case Apple:
                System.out.println("Ich möchte Äpfel essen");
                break;
            case Melon:
                System.out.println("Melone ist alles");
                break;
        }
    }
    
    protected enum Fruit {
        Orange,
        Apple,
        Melon
    };
    
}
//Ausführungsergebnis
Leckere Orangen

Bei der Definition von Feldern und Methoden
public class sample {
    public static void main(String[] args) {
        for(Fruit frt : Fruit.values()) {
            System.out.println(frt.ordinal() + ":" + frt.name() + "," + frt.getValue());
        }
    }
    protected enum Fruit {
        Orange("Ehime"),
        Apple("Aomori"),
        Melon("Ibaraki");
        
        //Feld definieren
        private String name;
        
        //Konstruktor definieren
        private Fruit(String name) {
            this.name = name;
        }
        
        //Methode
        public String getValue() {
            return this.name;
        }
    }
    
}
//Ausführungsergebnis
0:Orange,Ehime
1:Apple,Aomori
2:Melon,Ibaraki

extends

• Reservierte Wörter für die Klassenvererbung.
• Die erbende Klasse heißt "Basisklasse", "Superklasse", "Elternklasse" usw.
• Klassen, die die Basisklasse erben, werden als "abgeleitete Klassen", "Unterklassen", "kleine Klassen" usw. bezeichnet.
• Wenn Sie in einer abgeleiteten Klasse die Verarbeitung der Basisklasse ändern möchten, können Sie eine weitere Verarbeitung schreiben, ohne den Methodennamen oder das Argument dieser Verarbeitung zu ändern. Dies wird als Override bezeichnet.

Wann zu verwenden

• Die Menge des zu programmierenden Codes kann reduziert und die Lesbarkeit des Quellcodes verbessert werden.
• Durch die Definition einer übergeordneten Klasse kann diese in anderen untergeordneten Klassen verwendet werden, sodass der Code zusammen verarbeitet werden kann.

Beispielcode

public class Student{
　　String name;
　　int id;
　　attend(){}
}

public class School extends Student{
　　test(){}
}

interface

• Reservierte Wörter, die bei der Implementierung der Schnittstelle verwendet werden.
• Es gibt eine Regel, dass die Schnittstelle nur Konstanten und Methoden definieren kann.

Wann zu verwenden

• Verwenden Sie die in der Schnittstelle definierten Konstanten in der definierten Methode.
• Es ist dasselbe, wenn Sie definieren, was in der übergeordneten Klasse in der kleinen Klasse wie Klassenvererbung definiert ist, aber der große Unterschied zur Klassenvererbung besteht darin, dass die Klasse jeweils nur eine erben kann, während die Schnittstelle Kann viele gleichzeitig implementiert werden. Stattdessen müssen Sie alle Methoden definieren, die in der Schnittstelle definiert sind, in der Sie die Schnittstelle implementiert haben.

Beispielcode

//Eine Schnittstelle erstellen
interface Calc {
    int NUM1 = 1;
    int NUM2 = 2;
 
    void calc();
}
 
//Implementieren Sie die Schnittstelle und erstellen Sie eine Klasse zum Hinzufügen
class Add implements Calc {
    public void calc() {
        System.out.println(NUM1 + NUM2);
    }
}
 
//Implementieren Sie die Schnittstelle und erstellen Sie eine Klasse zum Subtrahieren
class Sub implements Calc {
    public void calc() {
        System.out.println(NUM1 - NUM2);
    }
}
 
//Erstellen Sie eine Klasse, die die Klasse ausführt, die die Schnittstelle implementiert
public class sample {
    public static void main(String[] args) {
        Add add = new Add();
        add.calc();
 
        Sub sub = new Sub();
        sub.calc();
    }
}
//Ausführungsergebnis
3
-1

implements

• Reservierte Wörter, die beim Implementieren einer Schnittstelle beim Definieren einer Klasse verwendet werden.

Wann zu verwenden

• Angenommen, die Schnittstelle ist definiert, verwenden Sie sie, wenn Sie sie in der Klasse implementieren möchten.

Beispielcode

public class Sample implementiert den Schnittstellennamen{}

private

• Zugriffsmodifikator.
• Zugriffsmodifikatoren: Steuern Sie die Zugriffsbeschränkungen definierter Klassen und wo ihre Mitglieder darauf zugreifen können.

Wann zu verwenden

• Ein Modifikator, auf den nur innerhalb der Klasse zugegriffen werden kann.

Beispielcode

class PublicClass {
    private String fieldVariable = "PublicClass-Feldvariablen.";
    
    public void publicMethod() {
        System.out.println(fieldVariable + "Ausgabe von publicMethod.");
    }
}
 
public class sample {
 
    public static void main(String[] args) {
        PublicClass pc = new PublicClass();
        pc.publicMethod();
    }
 
}
//Ausführungsergebnis
PublicClass-Feldvariablen.Ausgabe von publicMethod.

protected

• Zugriffsmodifikator.

Wann zu verwenden

• Ein Zugriffsmodifikator, mit dem auf eine Klasse im selben Paket oder auf ein anderes Paket innerhalb einer Unterklasse zugegriffen werden kann, die diese Klasse erbt.

Beispielcode

//Beim Referenzieren aus einer Unterklasse
class SuperClass {
    protected String str = "SuperClass-Variablen";
}
 
public class sample extends SuperClass {
 
    public static void main(String[] args) {
        sample sc = new sample();
        System.out.println(sc.str);
    }
 
}
//Ausführungsergebnis
SuperClass-Variablen

//Beim Referenzieren aus derselben Klasse
public class sample{
 
    public static void main(String[] args) {
        method();
    }
 
    protected static void method() {
        System.out.println("Methode mit geschützt");
    } 
}
//Ausführungsergebnis
Methode mit geschützt

//Wenn Sie nicht zugreifen können
class SuperClass {
    protected String str = "SuperClass-Variablen";
}
 
class SubClass_NG {
 
    public static void main(String[] args) {
        SubClass_NG sc = new SubClass_NG();
        System.out.println(sc.str);
    }
 
}
//Ausführungsergebnis
sample.java:9:Error:Symbol kann nicht gefunden werden

public

• Zugriffsmodifikator.

Wann zu verwenden

• Ein Modifikator, der es von überall zugänglich macht.
• Es gibt nur eine öffentliche Klasse und Schnittstelle pro Datei.
• Außerdem müssen der Dateiname ohne die Erweiterung, der Klassenname und der Schnittstellenname identisch sein.
• Der Zugriffsmodifikator, der in der Klasse direkt unter dem Paket gekocht werden kann, muss öffentlich sein.

Beispielcode

class PublicClass {
    public String fieldVariable = "PublicClass-Feldvariablen.";
    
    public void publicMethod() {
        System.out.println(fieldVariable + "Ausgabe von publicMethod.");
    }
}
 
public class sample {
 
    public static void main(String[] args) {
        PublicClass pc = new PublicClass();
        System.out.println(pc.fieldVariable);
    }
 
}
//Ausführungsergebnis
PublicClass-Feldvariablen.

package

• Reservierte Wörter zum Deklarieren der Erstellung eines Pakets.

Wann zu verwenden

• Wird beim Deklarieren eines Pakets verwendet.
• Was ist ein Paket: Ein Mechanismus zum Gruppieren und Trennen von Klassen und Schnittstellen.
• Grundsätzlich sind doppelte Klassennamen nicht zulässig, aber wenn die Pakete unterschiedlich sind, gibt es kein Problem, selbst wenn die Klassennamen abgedeckt sind.
• Daher wird das Paket verwendet, damit der Klassenname bei der Entwicklung mit mehreren Personen abgedeckt werden kann.

Beispielcode

package lang.java.hello;
 
public class HelloJava {
    public HelloJava() {
        System.out.println("Hello Java!");
    }
}
package lang.cpp.hello;
 
public class HelloCpp {
    public HelloCpp() {
        System.out.println("Hello C++!");
    }
}

import

• Reservierte Wörter zum Importieren von Paketen.

Wann zu verwenden

• Wird beim Importieren von Paketen verwendet.
• Beschreiben Sie wie folgt.

Paketnamen importieren.Klassenname, den Sie importieren möchten;

• Sie können alle Klassen in ein Paket importieren, indem Sie. * (Platzhalter) nach dem Paketnamen hinzufügen.

Beispielcode

import lang.cpp.hello.HelloCpp;
import lang.java.hello.HelloJava;
 
public class Main {
 
    public static void main(String[] args) {
        HelloJava hello1 = new HelloJava();
        HelloCpp hello2 = new HelloCpp();
    }
 
}

while

• Syntax für die iterative Verarbeitung.

Wann zu verwenden

• Die for-Anweisung kann die Anzahl der Iterationen angeben, die while-Anweisung wird jedoch verwendet, wenn Iterationen ausgeführt werden, für die die Anzahl nicht angegeben ist.

Beispielcode

public class sample {
    public static void main(String[] args) {
        int num = 0;
        while (num < 3) {
            System.out.println(num);
            num++;
        }
    }
}
//Ausführungsergebnis
0
1
2

goto

• Ungültiges reserviertes Wort in Java.
• In C / C ++ - Sprachen ein reserviertes Wort zum Springen zu einer bestimmten Zeile.

Wann zu verwenden

• Nicht verfügbar. Wenn Sie es verwenden, tritt ein Kompilierungsfehler auf.

Beispielcode

• Keiner

void

• Ein reserviertes Wort, das angibt, dass kein Rückgabewert vorhanden ist.

Wann zu verwenden

• Wird verwendet, wenn kein Rückgabewert der Methode vorhanden ist.
• Rückgabewert: Der Wert, der durch Ausführen des Prozesses ohne Methode zurückgegeben wird.

Beispielcode

public class sample {

    static String sampleMethod() {
  
        //Geben Sie die Zeichenfolge zurück
      return "Die Beispielmethode wurde aufgerufen";
    }
  
    public static void main(String[] args) {
  
        //Rufen Sie sampleMethod auf und weisen Sie das Ergebnis einer Variablen vom Typ String mit dem Namen str zu
        String str = sampleMethod();
  
        //Geben Sie den Inhalt der Variablen str aus
      System.out.println(str);
    }
  }
//Ausführungsergebnis
Die Beispielmethode wurde aufgerufen

return

• Reserviertes Wort bei Rückgabe des Rückgabewerts.

Wann zu verwenden

• 1. Bei Rückgabe eines Rückgabewerts.
• 2. Bei Verwendung in der Mitte einer Methode wird der Prozess an den Aufrufer zurückgegeben, ohne den nachfolgenden Prozess auszuführen.

Beispielcode

//Im Falle von 2
public class sample {
 
	public static void main(String[] args) {
		num(0, 2);
	}
 
	private static void num(int num1, int num2) {
		if (num1 == 0) {
			System.out.println("Kehren Sie zum Anrufer zurück.");
			return;
		}
		int addAns = num1 + num2;
		System.out.println("Die Antwort ist" + addAns + "ist.");
	}
 
}
//Ausführungsergebnis
Die Antwort ist 2.

//Wenn im selben Quellcode keine Rückgabe erfolgt
public class sample {
 
	public static void main(String[] args) {
		num(0, 2);
	}
 
	private static void num(int num1, int num2) {
		if (num1 == 0) {
			System.out.println("Kehren Sie zum Anrufer zurück.");
			
		}
		int addAns = num1 + num2;
		System.out.println("Die Antwort ist" + addAns + "ist.");
	}
 
}
//Ausführungsergebnis
Kehren Sie zum Anrufer zurück.
Die Antwort ist 2.
//Kommentar
Da es keine Rückgabe gibt, wurde die nächste Verarbeitung der if-Anweisung durchgeführt.

new

• Reservierte Wörter, die instanziiert werden können (Objekte erstellen).

Wann zu verwenden

• Wird beim Instanziieren verwendet.
• Ein Objekt, das basierend auf einer Klasse erstellt wurde
• Diejenige, die gleichzeitig beim Instanziieren ausgeführt wird, wird als Konstruktor bezeichnet.
• Schreiben Sie den Initialisierungsprozess in diese.

Beispielcode

Name der Hauptklasse der öffentlichen Klasse{
    public static void main(String[] args) {

        //Instanzgenerierung
Klassenname Variablenname=neuer Klassenname();
    }
}

Klasse Klassenname{

    //Konstruktor (wird beim Instanziieren ausgeführt)
Name der öffentlichen Klasse(){
Initialisierungsprozess usw.
    }
}

static

• Ein reservierter Begriff, mit dem Sie auf Variablen zugreifen können, ohne die Klasse zu instanziieren.

Wann zu verwenden

• Kann mit dem Klassennamen aufgerufen werden. Methodenname ();
• Wenn Sie die Initialisierungsverarbeitung nicht durchführen möchten, indem Sie bei jedem Aufruf eine Instanz erstellen. Wird verwendet, wenn Sie auf dasselbe Objekt zugreifen möchten.

Beispielcode

class ClassSample {
    private int val1 = 0; //Nicht statische Variablen(Instanzvariable)
    private static int val2 = 0; //statische Variable(Klassenvariable)
 
    //Fügen Sie der Variablen jedes Mal 1 hinzu, wenn die Konstruktorklasse instanziiert wird
    public ClassSample(int val1, int val2) {
        this.val1 += val1;
        ClassSample.val2 += val2; //"Name der Klasse.Deklarieren Sie eine statische Variable mit "Variablenname".
    }
 
    //Wert der Variablen anzeigen
    public void print(){
        System.out.println("val1 = " + val1 + ", val2 = " + val2);
    }
}
 
public class sample {
 
    public static void main(String[] args) { 
        for (int i = 0; i < 3; i++){
            ClassSample cs = new ClassSample(1, 1);
            cs.print();
        }
    }
 
}
//Ausführungsergebnis
val1 = 1, val2 = 1
val1 = 1, val2 = 2
val1 = 1, val2 = 3

final

• Ein reserviertes Wort, das eine Konstante darstellt.

Wann zu verwenden

• Kann für Klassen, Methoden bzw. Variablen verwendet werden.
• Für Variablen: Wird verwendet, wenn der Wert der Variablen oder des Referenzziels nicht geändert werden kann.
• Alle endgültigen Variablen sind lokale Variablen, Argumente und Felder (Instanzvariablen, Klassenvariablen).
• Für eine Klasse: Wird verwendet, wenn die Klasse nicht vererbt werden kann.
• Für Methoden: Wird verwendet, wenn ein Überschreiben nicht möglich ist.
• Abstrakte Klassen und Schnittstellen können nicht endgültig sein.
• Weil es nicht vererbt oder implementiert werden kann.

Beispielcode

//Für Variablen
int x = 0; //Ordentliche Variablendeklaration mit Anfangswert
x = 1;     //Ändern Sie den Wert einer Variablen
 
final int y = 10; //Deklarieren Sie die Variable als endgültig mit dem Anfangswert
y = 100;          //Die endgültige Variable kann nicht geändert werden und es tritt ein Kompilierungsfehler auf.!!
 
String s = "A"; //Normale Deklaration von Referenztypvariablen mit Anfangswert
s = "B";        //Ändern Sie das Referenzziel der Referenztypvariablen
 
final String s2 = "C"; //Die Variable vom Referenztyp wird als endgültig mit dem Anfangswert deklariert
s2 = "D";              //Die endgültige Variable kann nicht geändert werden und es tritt ein Kompilierungsfehler auf.!!

//Für den Unterricht
final class FinalSample {
}
 
class ChildFinalSample extends FinalSample { //Kompilierungsfehler!!Die letzte Klasse kann nicht vererbt werden
}

//Für Methoden
class FinalSample {
 final void method() { //Endinstanzmethode
 }
}
 
class ChildFinalSample extends FinalSample { //Da es sich nicht um eine Abschlussklasse handelt, kann sie vererbt werden
 void method() { //Kompilierungsfehler!!Die Methode der endgültigen Instanz kann nicht überschrieben werden
 }
}

_

• Ungültiges reserviertes Wort in Java.

Wann zu verwenden

• verwende nicht.

Beispielcode

• Keiner

float

• Ein Basisdatentyp, der einen Bruchwert in 32 Bit darstellt.

Wann zu verwenden

• Wird verwendet, wenn Sie einen Wert in einem schwebenden Bruch ausdrücken möchten.
• Floating Species Number: Numerische Daten, die davon ausgehen, dass bei der Berechnung ein Fehler auftritt.
• Unterschied zum Doppel: Unterschied in der Anzahl der Bits, die verarbeitet werden können
• double : 64bit | float : 32bit

Beispielcode

public class sample {
  public static void main(String[] args) {
    float f = 1.25f;
    int num = 10;
    float addNum = num + f;

    System.out.println(num + " + " + f + " = " + addNum);
  }
}
//Ausführungsergebnis
10 + 1.25 = 11.25

int

• Ein grundlegender Datentyp, der eine Ganzzahl in 32 Bit darstellt.

Wann zu verwenden

• Da es sich um eine Ganzzahl handelt, werden Werte verarbeitet, die um 1 erhöht oder verringert werden. Es kann ganze Zahlen bis zu ± 2,1 Milliarden darstellen.
• Wie schreibe ich int Literale
• Binärzahl (beginnend mit "0b" ab Java 7)
• 8 Basisnummern (beginnend mit "0")
• Ablehnen (ohne Präfix)
• Sechseck (beginnend mit "0x")
• Was ist Integer?
• Da es sich um einen Objekttyp handelt, wird er als Klasse behandelt.
• Wird verwendet, wenn Sie vom int-Typ in den String-Typ umwandeln möchten.
• null ist verfügbar.

Beispielcode

int i1 = 123456789; //Dezimalzahl
int i2 = 0b1010101; //Binärzahl
int i3 = 012345670; //8 Basis
int i4 = 0x123ABCDE; //Hexadezimal
int i5 = 123_456_789; //Zifferntrennzeichen(Alle 3 Ziffern)
int i6 = 0b1111_1010_0101; //Zifferntrennzeichen(Alle 4 Bits)

long

• Ein grundlegender Datentyp, der eine Ganzzahl in 64 Bit darstellt.

Wann zu verwenden

• Wird verwendet, wenn große Zahlen verarbeitet werden, die vom Typ int nicht verarbeitet werden können.
• int
• Maximalwert: 2 ^ 32-1
• Mindestwert: -2 ^ 31
• long
• Maximalwert: 2 ^ 63-1
• Mindestwert: -2 ^ 63

Beispielcode

public class sample {
    public static void main(String [] args) {
      int m = 2147483647;
      System.out.println(m);
      
      m += 1;
      System.out.println(m);
  
      long n = 2147483647;
      System.out.println(n);
    
      n += 1;
      System.out.println(n);
    }
  }
//Ausführungsergebnis
2147483647
-2147483648
2147483647
2147483648

short

• Basisdatentyp, der eine Ganzzahl in 16 Bit darstellt.

Wann zu verwenden

• Wird beim Umgang mit Nummern zwischen -32768 und 32767 verwendet.
• Nicht hohe Kreditfrequenz.
• int > long > short
• Wenn eine Operation vom Typ kurz ausgeführt wird, wird das Operationsergebnis als int-Typ zurückgegeben. Wenn also ein Wert nicht von einer Variablen vom Typ int empfangen wird, tritt ein Kompilierungsfehler auf.

Beispielcode

public class sample {
    short a=100;
    short b=10;
    short c=0;
    
    c = a + d;
    System.out.println("c =" + c );
  }
//Ausführungsergebnis
sample.java:6:Error: <identifier>da ist nicht

instanceof

• Ein reservierter Begriff, der bestimmt, ob die Klasse, auf die die Variable verweist, korrekt ist.

Wann zu verwenden

• Bei Bezugnahme auf den Datentyp.
• Wenn festgestellt wird, ob eine Unterklasse eine Oberklasse erbt.
• Bei der Feststellung, ob eine Schnittstelle implementiert ist.

Beispielcode

//Wenn Sie sich auf den Datentyp beziehen
public class sample {
    public static void main(String[] args) {
 
        Object obj = "samurai";
        System.out.println(obj instanceof String);
        System.out.println(obj instanceof Integer);
    }
}
//Ausführungsergebnis
true
false

//Feststellen, ob eine Unterklasse eine Spar-Klasse erbt
public class sample {
    public static void main(String[] args) {
 
        SubClass sub = new SubClass();
        System.out.println(sub instanceof SubClass);
        System.out.println(sub instanceof SuperClass);
    }
}
 
class SuperClass {}
class SubClass extends SuperClass{}
//Ausführungsergebnis
true
true

//Feststellen, ob eine Schnittstelle implementiert ist
public class sample {
    public static void main(String[] args) {
 
        SubClass sub = new SubClass();
        System.out.println(sub instanceof SubClass);
        System.out.println(sub instanceof Interface);
    }
}
 
interface Interface {}
class SuperClass implements Interface {}
class SubClass extends SuperClass {}
//Ausführungsergebnis
true
true

this

• Ein reserviertes Wort, das sich selbst bedeutet.

Wann zu verwenden

• Wenn auf Methoden und Variablen derselben Klasse verwiesen wird.
• Beim Aufrufen eines anderen Konstruktors.

Beispielcode

//Beim Verweisen auf Methoden und Variablen derselben Klasse
public class sample {

    //Beispielklassenvariable
    String animal = "Kaninchen";

    public void printAnimal() {

      //Lokale Variablen
      String animal = "Katze";
      System.out.println("Lokales variables Tier:" + animal);
      System.out.println("Klasse variables Tier:" + this.animal);

    }

    public static void main(String[] args) {

        sample s = new sample();
        s.printAnimal();

      }
  }
//Effektives Ergebnis
Lokales variables Tier:Katze
Klasse variables Tier:Kaninchen

//Beim Aufruf eines anderen Konstruktors
class ThisSample8 {
    String name;
    int amount;
    
    //① Standardkonstruktor
    ThisSample8() {
    this("Anonym Gonbei", 10); //Rufen Sie ③ mit dem Standardwert auf
    }
    
    //② Überladener Konstruktor(Teil 1)
    ThisSample8(String name) {
    this(name, 20); //Rufen Sie ③ auf, während Sie Argumente verwenden
    }
    
    //③ Überladener Konstruktor(Teil 2)
    ThisSample8(String name, int amount) {
    //Die Feldinitialisierung erfolgt nur mit diesem Konstruktor
    this.name = name;
    this.amount = amount;
    }
    
    void printProperty() {
    System.out.println(String.format("mein Name ist%s. Das Geld, das du hast%Es ist D Yen.", name, amount));
    }
    
    public static void sample(String[] args) {
    ThisSample8 sample1 = new ThisSample8();
    sample1.printProperty(); //→ Anonym Gonbei, 10 Yen
    
    ThisSample8 sample2 = new ThisSample8("Yamada Taro");
    sample2.printProperty(); //→ Taro Yamada, 20 Yen
    
    ThisSample8 sample3 = new ThisSample8("Jiro Suzuki", 1000);
    sample3.printProperty(); //→ Jiro Suzuki, 1000 Yen
    }
   }
//Ausführungsergebnis
Ich heiße Anonymous Gonbei. Das Geld, das Sie haben, ist 10 Yen.
Ich heiße Taro Yamada. Das Geld, das Sie haben, ist 20 Yen.
Ich heiße Jiro Suzuki. Das Geld, das Sie haben, ist 1000 Yen.

super

• Reservierte Wörter zum Verweisen auf Instanzen und Mitglieder der Oberklasse.

Wann zu verwenden

• Beim Aufruf des Konstruktors einer Superklasse.
• Beim Aufrufen der Methode vor dem Überschreiben.

Beispielcode

//Beim Aufruf des Konstruktors einer Superklasse
public class sample {
    public static void main(String[] args) throws Exception {
        
        SubClass sub = new SubClass();
    }
}
 
class SuperClass {
 
    public SuperClass(){
        System.out.println("Super_Const");
    }
 
    public SuperClass(String str){
        System.out.println("str : " + str);
    }
    public SuperClass(int num){
        System.out.println("num : " + num);
    }
}
 
class SubClass extends SuperClass {
 
    public SubClass(){
        super("apple");
    }
}
//Ausführungsergebnis
str : apple
//Beim Aufrufen der Methode vor dem Überschreiben
class SuperClassSample {
    String str = "SuperClass";
 
    public String getSrt() {
        return str;
    }
}
 
class SubClassSample extends SuperClassSample {
    String str = "SubClass";
 
    public String getSrt() {
        return str;
    }
 
    public void print() {
        System.out.println("super.str = " + super.str);
        System.out.println("str = " + str);
 
        System.out.println("super.getSrt() = " + super.getSrt());
        System.out.println("getSrt() = " + getSrt());
    }
}
 
public class sample {
    public static void main(String[] args) {
 
        SubClassSample scs = new SubClassSample();
        scs.print();
 
    }
}
//Ausführungsergebnis
super.str = SuperClass
str = SubClass
super.getSrt() = SuperClass
getSrt() = SubClass

native

• Ein Modifikator, der eine Methode angibt, die in einer anderen Sprache als Java geschrieben wurde.

Wann zu verwenden

• Es gibt einen Mechanismus namens JNI (Java Native Interface), der nativen Code wie C / C ++ verknüpft.
• Es wird tatsächlich im UCS-Quellcode verwendet.
• Definieren Sie den Methodennamen wie eine Schnittstelle in einer Java-Datei.
• Wenn Sie die c-Datei mit JNIEXPORT definieren, werden die Java-Datei und die c-Datei zugeordnet.
• Der in der Java-Datei beschriebene Methodenname ist der Name der Methode, die tatsächlich in der c-Datei verarbeitet wird.

Beispielcode

//Java-Datei
pablic native boolean isCameraMute();

//c-Datei
JNIEXPORT jboolesches JNICALL-Präfix_isCameraMute();
return isCsmeraMute();

strictfp

• Ein reserviertes Wort für die strikte Verarbeitung von Gleitkommazahlen gemäß den im Standard IEEE754 definierten Regeln.
• Klassen, Schnittstellen und Methoden können verwendet werden, Variablen können jedoch nicht geändert werden.

Wann zu verwenden

• Was ist IEEE (Institute of Electrical and Electronics Enginners)? Eine akademische Forschungsorganisation auf dem Gebiet der Elektro- und Informationstechnik mit Sitz in den USA. Technologiestandardisierungsgremium.
• Was ist IEEE754: Ein Standard für Gleitkommazahlen. Es wird verwendet, um das gleiche Ergebnis in jeder Umgebung zu erzielen, in der der Fehler der Gleitkommaberechnung je nach 32-Bit oder 64-Bit unterschiedlich ist.
• Wenn strictfp nicht verwendet wird, hängt dies von der CPU des PCs ab.

Beispielcode

public class sample {
    public static void main(String args[]) {
        new sample();
    }
    //Konstruktor generieren
    public sample() {
        this.strictfpTest();
    }

    strictfp public void strictfpTest() {
        double a = 0.01;
        double b = 0.02;
        double c = 0.0001;

        System.out.println(a * b * c);
    }
}
//Ausführungsergebnis
2.0E-8

synchronized

• Reserviertes Wort für exklusive Kontrolle.

Wann zu verwenden

• Wird verwendet, wenn eine exklusive Kontrolle durchgeführt wird.
• Exklusive Kontrolle: Verhindert den gleichzeitigen Zugriff auf gemeinsam genutzte Ressourcen, die von mehreren Prozessen verwendet werden können.

Beispielcode

//Wenn nicht synchronisiert
public class sample{
    public static void main(String[] args) {
        Bathroom bathroom = new Bathroom();
        FamilyTread father = new FamilyTread(bathroom, "Vater");
        FamilyTread mother = new FamilyTread(bathroom, "Mutter");
        FamilyTread sister = new FamilyTread(bathroom, "Schwester");
        FamilyTread me = new FamilyTread(bathroom, "ich");

        father.start();
        mother.start();
        sister.start();
        me.start();
    }
}

class FamilyTread extends Thread {
    private Bathroom mBathroom;
    private String mName;

    FamilyTread(Bathroom bathroom, String name) {
        this.mBathroom = bathroom;
        this.mName = name;
    }

    public void run() {
        mBathroom.openDoor(mName);
    }

}

class Bathroom {
    void openDoor(String name) {
        System.out.println(name + ""Ich werde ein Bad nehmen!"");
        for (int count = 0; count < 100000; count++) {
            if (count == 1000) {
                System.out.println(name + ""Ich habe ein Bad genommen."");
            }
        }
        System.out.println(name + ""Ich bin aus dem Bad gestiegen!"");
    }
}
//Ausführungsergebnis
Vater "Ich nehme ein Bad!"
Mutter "Ich nehme ein Bad!"
Vater "Ich habe gebadet."
Meine Schwester "Ich nehme ein Bad!"
Ich nehme ein Bad!"
Mutter "Ich habe gebadet."
Ich "Ich habe ein Bad genommen."
Meine Schwester "Ich habe ein Bad genommen."
Vater "Ich bin aus dem Bad gestiegen!"
Meine Schwester "Ich bin aus dem Bad gestiegen!"
Ich "Ich bin aus dem Bad gestiegen!"
Mutter "Ich bin aus dem Bad gestiegen!"

//Wenn synchronisiert wird für Klasse Badezimmer verwendet
class Bathroom {
    synchronized void openDoor(String name) {
        System.out.println(name + ""Ich werde ein Bad nehmen!"");
        for (int count = 0; count < 100000; count++) {
            if (count == 1000) {
                System.out.println(name + ""Ich habe ein Bad genommen."");
            }
        }
        System.out.println(name + ""Ich bin aus dem Bad gestiegen!"");
    }
//Ausführungsergebnis
Vater "Ich nehme ein Bad!"
Vater "Ich habe gebadet."
Vater "Ich bin aus dem Bad gestiegen!"
Ich nehme ein Bad!"
Ich "Ich habe ein Bad genommen."
Ich "Ich bin aus dem Bad gestiegen!"
Mutter "Ich nehme ein Bad!"
Mutter "Ich habe gebadet."
Mutter "Ich bin aus dem Bad gestiegen!"
Meine Schwester "Ich nehme ein Bad!"
Meine Schwester "Ich habe ein Bad genommen."
Meine Schwester "Ich bin aus dem Bad gestiegen!"

transient

• Ein Modifikator, der Objekte von der Serialisierung ausschließt.

Wann zu verwenden

• Serialisierung: Konvertieren des Inhalts eines Objekts in ein Byte-Array, damit es in einer Datei gespeichert oder an einen anderen Computer gesendet werden kann.
• Wenn die serialisierbare Schnittstelle implementiert ist, werden standardmäßig alle Felder serialisiert, sie werden jedoch verwendet, wenn Sie sie ausschließen möchten.
• Wenn Sie den Status nicht speichern müssen.
• Entspricht dem Feld, das Sie beim Wiederherstellen eines serialisierten Felds initialisieren möchten.
• Wenn die Klasse, die Sie serialisieren möchten, nicht serialisierbare Felder enthält.
• Die Felder der zu serialisierenden Klasse müssen primitiv oder serialisierbar sein.
• Klassen, die nicht serialisiert werden können: Liste, Karte, Verbindung, InputStream usw.
• Methode, die die Eingabe / Ausgabe der Serialisierung tatsächlich durchführt: write.Object () S.

Beispielcode

//Main.java
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream; 
import java.io.ObjectOutputStream; 
import java.io.Serializable;

public class Main { 
    public static void main(String[] args) throws Exception { 
        Player player = new Player(new Badminton()); 
        player.play();         System.out.println();

        Player clonePlayer = deepCopy(player); 
        clonePlayer.play(); 
        System.out.println();

        System.out.print("Gleiche Instanz von Player:"); 
        System.out.println(player == clonePlayer); 
        System.out.print("Gleiche Instanz von Badminton:"); 
        System.out.println(player.getSports() == clonePlayer.getSports()); 
    }

    @SuppressWarnings("unchecked") 
    public static <T extends Serializable> T deepCopy(T t) throws Exception { 
        if (t == null) { 
            return null; 
        }

        ByteArrayOutputStream byteOut = null; 
        ObjectOutputStream objectOut = null; 
        try { 
            byteOut = new ByteArrayOutputStream(); 
            objectOut = new ObjectOutputStream(byteOut); 
            objectOut.writeObject(t); 
        } finally { 
            objectOut.close(); 
        }

        ObjectInputStream objectin = null; 
        T copy = null; 
        try { 
            objectin = new ObjectInputStream(new ByteArrayInputStream
                                                     (byteOut.toByteArray())); 
            copy = (T) objectin.readObject(); 
        } finally { 
            objectin.close(); 
        } 
        return copy; 
    } 

}

//Sports.java
public interface Sports { 
    void play(); 
}

class Badminton implements Sports { 
    @Override 
    public void play() { 
        System.out.println("Spiel mit Badminton."); 
    } 
}

//Player.java
import java.io.Serializable;

@SuppressWarnings("serial") 
public class Player implements Serializable { 
    private transient Sports sports;

    public Player(Sports sports) { 
        this.sports = sports; 
        System.out.println("Es ist ein Konstruktor."); 
    }

    public Sports getSports() { 
        return sports;    
 }
 public void play() { 
        System.out.println("Sich warm laufen.");

        sports.play();

        System.out.println("Abkühlen"); 
    } 
}

volatile

• Ein Modifikator, der den Wert der Variablen in jedem Thread mit dem gemeinsam genutzten Speicher übereinstimmt.

Wann zu verwenden

• Um das Caching von Feldwerten zu unterdrücken.
• Beim Multithreading kann jeder Thread denselben Gefühlswert zwischenspeichern. Zu diesem Zeitpunkt besteht das Risiko, dass die Werte auch im selben Feld unterschiedlich sind.
• Was ist ein Cache? Durch Anzeigen eines Werts an einer anderen Stelle als dem Hauptspeicher ist die Speichermenge im Allgemeinen kleiner als die des Speichers, aber der Wert kann mit hoher Geschwindigkeit aufgerufen und aktualisiert werden.
• Um zu verhindern, dass der Compiler optimiert.
• Was ist ein Compiler: Software, die Computerprogramme, die in High-Level-Programmierung (C, Java usw.) geschrieben wurden und für den Menschen leicht verständlich sind und komplizierte Funktionen und Syntax haben, gemeinsam in ein Format konvertiert, das von einem Computer interpretiert und ausgeführt werden kann.

Beispielcode

public class VolatileSample {
 
    private static volatile int count = 0;
    //private static int count = 0;
 
    public static void main(String[] args) {
        new MultiThread1().start();
        new MultiThread2().start();
    }
 
    static class MultiThread1 extends Thread {
        public void run() {
            int val = count;
            while(count < 3) {
                if (val != count) {
                    String message = getName() + ": val = " + val + ", count = " + count;
                    System.out.println(message + "aktualisieren");
                    val = count;
                }
            }
        }
    }
 
    static class MultiThread2 extends Thread {
        public void run() {
            int val = count;
            while(count < 3) {
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                String message = getName() + ": val = " + val + ", count = " + count;
                System.out.println(message);
                count = ++val;
            }
        }
    }
}
//Ausführungsergebnis
Thread-1: val = 0, count = 0
Thread-0: val = 0, count =1 Update
Thread-1: val = 1, count = 1
Thread-0: val = 1, count =2 Update
Thread-1: val = 2, count = 2