[Java] Java SE 8 Silver Note

Prüfungstipps

• Lesen Sie die Fragen sorgfältig durch (übersehen Sie nicht die richtigen, falschen, 3 usw.) --Überprüfen Sie den Variablentyp und den Zugriffsmodifikator sorgfältig. Achten Sie auf Typinkongruenzen und Berechtigungsprobleme

Java-Grundlagen

• Auf Klassen, die zu anonymen Paketen gehören, kann nur von Paketen zugegriffen werden, die zu anonymen Paketen gehören Wenn protected von einer Klasse in einem anderen Paket geerbt wird, kann von der geerbten Klasse auf sie zugegriffen werden, auf das anonyme Paket kann jedoch nicht zugegriffen werden (die Einschränkung des anonymen Pakets hat Vorrang). --Package hat kein Konzept der Hierarchie

Bearbeiten von Java-Datentypen

--Underbar (_) kann für Literale verwendet werden (mit den folgenden Einschränkungen)

• Kann nicht am Anfang und Ende des Literal beschrieben werden (NG: _0)
• Kann nicht vor oder nach dem Symbol verwendet werden (NG: 0_.0)
• Der Standardwert für Dezimalpunktliterale ist doppelt Wenn Sie einer Float-Variablen ein Literal zuweisen, müssen Sie daher den Typ (Schneider) angeben.

  float f = 0.0f;

• Namen (Bezeichner) von Variablen, Methoden, Klassen usw. unterliegen den folgenden Einschränkungen --Reservierte Wörter können nicht verwendet werden
• Es können nur Unterbalken (_) und Währungssymbole ($ usw.) verwendet werden.
• Beginnen Sie nicht mit Zahlen --byte Typ ist eine 8-Bit-Ganzzahl (-128 oder ~ 127)

  byte b = 0b1000000;
→ 128 aufgrund eines Fehlers
  byte b = (byte)0b1000000;
  →-OK für 128

--Casting ist für die Zuordnung zu einem höheren Typ nicht erforderlich (long if int) (upcast)

  int a = 1;
  long b = a;

  float f = 0.0f;
  double d = f;

• Cast wird für die Zuordnung zum unteren Typ benötigt (Downcast)

  long a = 1;
  int b = (int)a;

  double d = 0.0;
  float f = (float)d;

• Gleiche Regeln für Klassen

Verwendung von Operatoren und Beurteilungsstrukturen

• Die Equal-Methode ist in der Object-Klasse definiert und eine Instanzprüfung (Identitätsprüfung).
• Die Equal-Methode der String-Klasse ist eine String-Prüfung (Äquivalenzprüfung).
• Beachten Sie die obigen Punkte, wenn Sie Probleme haben, die gleiche Methode zu überschreiben
• Da String-Literale in einem konstanten Pool abgelegt werden und dieselben Literale gemeinsam genutzt werden, gelten folgende Bedingungen:

  String a = "aaa"
  String b = "aaa"
  System.out.println(a == b);
→ true wird angezeigt

• Wenn Sie den Prozess mit einem Zeilenumbruch in die if-Anweisung schreiben, fügt der Compiler gegebenenfalls mittlere Klammern hinzu (achten Sie auf den Trigger).

  int num = 10;
  if (num == 100)
    System.out.println("A");
  else if (num > 10)
    System.out.println("B");
  else
  if (num == 10)
    System.out.println("C");
  else
  if (num == 10)
    System.out.println("D");

Compiler-Interpretation

  int num = 10;
  if (num == 100) {
    System.out.println("A");
  } else if (num > 10) {
    System.out.println("B");
  } else {
    if (num == 10) {
      System.out.println("C");
    } else {
      if (num == 10) {
        System.out.println("D");
      }
    }
  }

--Long und Boolean sind nicht in den Typen enthalten, die an die switch-Anweisung übergeben werden können! --Variablen können unter Switch-Bedingungen nicht verwendet werden

Erstellen und Verwenden von Arrays

• Geben Sie nicht die Anzahl der Elemente in der Array-Typdeklaration an (Kompilierungsfehler).

  //Grundform
  int [] a;
  //Das ist nicht gut
  int [3] a;

• Stellen Sie beim Initialisieren eines Arrays nicht gleichzeitig die Anzahl der Elemente und den Anfangswert ein (Kompilierungsfehler).

  //Grundform
  int [] a = new int []{1, 2};
  //Das ist nicht gut
  int [] a = new int [2]{1, 2};

• Deklarieren Sie das Array nicht und legen Sie den Anfangswert separat fest (Kompilierungsfehler)

  //Grundform
  int [] a = new int []{1, 2};
  //Das ist nicht gut
  int [] a;
  a = {1, 2};

Verwendung der Schleifenstruktur

• Keine besonderen Vorsichtsmaßnahmen

Methoden und Kapselungsoperationen

• Argumentdeklaration mit variabler Länge
• Definieren Sie wie folgt

  void sample(int... num) {
    for (int i = 0; i < num.length; i++) {
      System.out.println(num[i]);
    }
  }

• Argumente variabler Länge werden als Array übergeben --Variables Längenargument kann nur am Ende angegeben werden

  void sampl(int... num, int pos) {
→ Fehler
  }

• Zugriffsstärke des Zugriffsmodifikators --public: von allen Klassen zugänglich --protected: Nur für Unterklassen zugänglich, die zum selben Paket gehören oder von diesem erben
• Kein Modifikator: Zugriff über Klassen, die zum selben Paket gehören --private: nur innerhalb der Klasse zugänglich --Hinweis: Auf Klassen, die zu anonymen Paketen gehören, kann nur von Klassen zugegriffen werden, die zu demselben anonymen Paket gehören
• Das Qualifikationsmerkmal der geerbten Methode ist das gleiche oder das gleiche wie das ursprüngliche Qualifikationsmerkmal. (ex: protected: protected or public)
• Der Zugriffsmodifikator der Interface-Abstract-Methode ist "public".
• Auf nur statisch qualifizierte Methoden kann über statisch qualifizierte Methoden zugegriffen werden.

  public class Main {
    int num;
    private static void test() {
      num++;
→ Kompilierungsfehler
      System.out.ptintln(num)
    }

--Implizite Typkonvertierung verursacht Kompilierungsfehler "Mehrdeutiger Methodenaufruf"

  public class Main {
    public static void main(String [] args) {
      Main m = new Main();
      System.out.println(m.calc(2, 3));
      →2,3 kann auch durch implizite Typkonvertierung als Double interpretiert werden
Ich kann nicht feststellen, welche der überladenen Methoden aufgerufen werden soll. .. ..
→ Kompilierungsfehler in "Mehrdeutiger Methodenaufruf"
    }

    private double calc(double a, int b) {
      return (a + b) / 2;
    }

    private duoble calc(int ak double b) {
      return (a + b) / 2;
    }
  }

  public class Main {
    public Main() {
      System.out.println("A");
      this("B");
→ Kompilierungsfehler
    }
    public Main(String str) {
      System.out.println("B");
    }
  
    public static void main(String [] args) {
      Main m = new Main();
    }
  }

--protected kann in geerbten Klassen referenziert werden (kann aber nicht als Instanzmethode aufgerufen werden) Natürlich wird es wahrscheinlich missverstanden.

  package other;
  
  public class Book {
    private String isbn;
    public void setIsbn(String isbn) {
      this.isbn = isbn;
    }
    protected void printInfo() {
      System.out.println(this.isbn);
    }
  }

  package pkg;
  import other.Book;
  
  public class StoryBook extends Book {}

  package pkg;
  
  public class Main {
    public static void main(String [] args) {
      StoryBook sb = new StoryBook();
      sb.setIsbn("xxxx-xxxx-xxxx");
      sb.printInfo();
→ Kompilierungsfehler
    }
  }

Vererbungsbetrieb

• Unterklassen erben keine Konstruktoren, privaten Felder oder Methoden
• Vererbungsregeln --Klassen haben nur eine einzige Vererbung
• Zwischen Schnittstellen ist eine Mehrfachvererbung möglich --Polymorphismus ist nicht nur eine Klasse mit einer Vererbungsbeziehung, sondern auch eine Beziehung zwischen Schnittstelle und Implementierung.

  interface Worker() {
    void work();
  }
  
  class Employee {
    public void work() {
      System.out.println("work");
    }
  }
  
  class Engineer extend Employee implements Worker { }
  
  public class Main {
    public static void main(String [] args) {
      Worker w = new Engineer();
→ Arbeit wird ausgegeben (es tritt kein Kompilierungsfehler auf)
    }
  }

Ausnahmen behandeln

--Exception-Klassen sind grob in Error, Exception und RuntimeException unterteilt. --Error: Ein Fehler, der nicht aus dem Programm wiederhergestellt werden kann (OutOfMemoryError, StackOverflowError, NoClassDefFoundError usw.) → Auch nach Inspektion nicht wiederherstellbar

• Geprüfte Ausnahme: Ausnahme und ihre Unterklassen
• Ungeprüfte Ausnahmen: Fehler aufgrund von Programmierfehlern (RuntimeException und ihre Unterklassen, wie z. B. NullPoiterException)
• Geprüfte Ausnahmen müssen behandelt werden (gezwungen, die Klauseldeklaration zu versuchen oder zu werfen)
• Wenn bei der Verarbeitung eines statischen Initialisierers ein Problem auftritt, löst die JVM einen ExceptionInitializerError aus und beendet das Programm, da kein Benachrichtigungspartner vorhanden ist.

  public class Main {
    private static String name;
    static {
      if (name.length() == 0) {
→ Länge mit nicht initialisiertem Namen()Verursacht einen Fehler, weil Sie angerufen haben
        name = "sample"
      }
      public static void main(String[] args){
        System.out.println("hellow " + name);
      }
  }

• Für double try-catch-finally wird die finally-Klausel immer ausgeführt

  public class Main() {
    public static void main(String[] args) {
      try {
        try {
          String[] array= {"a", "b", "c"};
          System.out.println(array[3]);
        } catch (ArrayIndexOuntOfBoundsException e) {
          System.out.println("D");
        } finally {
          System.out.println("E");
→ ausgeführt
        }
      } catch (ArrayIndexOutOfBoundsException e) {
        System.out.println("F");
      } finally {
        System.out.println("G");
→ ausgeführt
      }
    }
  }
  →"D E G"Wird angezeigt

  public class Main() {
    public static void main(String[] args) {
      System.out.println(test(null));
→ Anzeige A
    }
    private static String test(Object obj) {
      try {
        System.out.println(obj.toString());
      } catch (NullPointerException e) {
        return "A";
→ A wird auf den Stapel gelegt
      } finally {
        System.out.println("B");
→ Ausgabe B vor der Rückkehr
      }
    }
  }
  →"B A"Wird angezeigt

Hauptklassenoperationen der Java-API

• So generieren Sie ein String-Objekt

  String a = new String("sampl");
  String b = "sample"
  String c = String.valueOf("sample");

• Wenn Sie ein String-Objekt verketten (+), dem null zugewiesen ist, wird es in "null" konvertiert und verkettet.

  String a = null;
  a += "null";
  System.out.println(a)
  →"nullnull"Wird angezeigt

--StringBulider verwaltet Daten intern mit char [] und verfügt standardmäßig über einen Puffer für 16 Zeichen

  StringBuilder sb = new StringBuilder("abcde");
  System.out.println(sb.capacity());
→ 21 wird oft verwendet(16 Zeichen im Puffer+5)

• Bezüglich der Syntax von Lambda-Ausdrücken

• Wenn Sie die mittlere Klammer im Lambda-Ausdruck weglassen, kann der Vorgang in einem Satz beschrieben werden. Derzeit kann die Rückgabe nicht beschrieben werden --Return kann nicht weggelassen werden, wenn die mittlere Klammer im Lambda-Ausdruck beschrieben ist.

  Function f = str -> "hello " + str;
  Function f = str -> { return "hello " + str };
  

• Eine Variable mit demselben Namen wie eine in einer Lambda-Methode deklarierte lokale Variable kann nicht als Lambda-Ausdrucksvariable verwendet werden

  public class Main {
    public static void main(String[] args) {
      String val = "A";
      Function f = (val) -> { System.out.println(val); };
→ Kompilierungsfehler
    }
    interface Function { void test(String val); }
→ Funktionsschnittstelle
  }

• Um von einem Lambda-Ausdruck aus auf eine außerhalb eines Lambda-Ausdrucks deklarierte lokale Variable zugreifen zu können, muss es sich um eine im Wesentlichen endgültige Variable handeln (andernfalls um einen Kompilierungsfehler).

  public class Sample {
    public static void main(String[] args) {
      int cnt = 0;
      Runnable r = () -> {
        for (cnt = 0;  cnt < 10; i++) {
→ Kompilierungsfehler(Nicht final. .. ..)
          System.out.println(cnt++);
        }
      }
      new Thread(r).start();
    }
  }

• Die Methode equals von StringBuilder vergleicht Objekte (vergleicht keine Werte)
• Eine Ausnahme wird ausgelöst, wenn im Konstruktor der LocalDate, LocalDateTime-Klasse ein mögliches Datum angegeben ist. --LocalData, LocalDateTime-Klassen sind unveränderlich (interne Daten werden nicht aktualisiert)