[Java] Objektorientierte Syntaxklassenmethode / Argument

Klassenmethode / Feld

• Felder / Methoden, die direkt aus der Klasse aufgerufen werden können ** ohne Instanziierung **
• ** Auch statische Methode / statische Methode genannt **
• ** Klassenmitglieder **
• Klassenmethode
• Klassenfeld
• Es gibt nur ein Klassenmitglied in der Klasse, das von allen Instanzen gemeinsam genutzt wird
• cf: ** Instanzmitglied **: Mitglied, das über ein Objekt aufgerufen werden soll
• Jeder hat einen unabhängigen Wert (tatsächlicher Zustand)

Klassenmethode

• ** Füge einfach statisch hinzu **
• Hinweis
• ** Dies kann nicht in Klassenmethoden verwendet werden **
• Die Instanz selbst wurde nicht erstellt
• Instanzfelder / -methoden können nicht von Klassenmethoden referenziert werden
• ** Klassenmethoden werden nicht über Objekte aufgerufen **

//Definieren Sie die Klassenmethode getTriangleArea für die Figure-Klasse
public class Figure {
  public static double getTriangleArea(double width, double height) {
    return width * height / 2;
  }
}

StaticBasic.java

public class StaticBasic {

  public static void main(String[] args) {
    System.out.println(Figure.getTriangleArea(10, 20));
//    var f = new Figure();
//    System.out.println(f.getTriangleArea(10, 20));
  }
}

Utility-Klasse

• Eine Klasse, die nur Klassenmitglieder hat (Matheklasse usw.)
• Verbessern Sie die Lesbarkeit und erleichtern Sie das Auffinden von Funktionen, indem Sie verwandte Funktionen in einer Klassenmethode gruppieren.
• Die Matheklasse bündelt die numerische Verarbeitung
• ** Klasseninstanziierung kann verboten werden, indem der Konstruktor privat gemacht wird (kann nicht von außen aufgerufen werden) **
• var m = new Math (); // error
• Es ist üblich, den ** endgültigen Modifikator ** zu verwenden, um die Klassenvererbung explizit zu verbieten

public final class Math{
  private Math() {}
}

Klassenfeld

• Felder, die direkt aufgerufen werden können, ohne eine Instanz zu durchlaufen
• ** Füge einfach statisch hinzu **
• Auf Klassenfelder kann über Klassenmethoden zugegriffen werden
• Weil das Klassenfeld zur Klasse gehört
• Kann von außen aufgerufen werden, wenn Zugriffsrechte erfüllt sind
• Hinweis: Klassenfelder ** wirken sich auf alle relevanten Instanzen aus, wenn Sie deren Inhalt ändern **
• In anderen Sprachen ** Globale Variablen **: Variablen, die im gesamten Programm gültig sind
• ** Da die Abhängigkeit zwischen Klassen stärker wird **, verwenden Sie sie im Prinzip unter den folgenden Bedingungen
• Schreibgeschützt
• Statusüberwachung der Klasse selbst
• ** Beispiel: Singleton-Muster ** (siehe unten)

Figure.java

//Definition des Pi-Felds und der getCircleArea-Methode im Klassenmitglied der Figure-Klasse

public class Figure {
  public static double pi = 3.14;

  //Greifen Sie über Klassenmethoden auf Klassenfelder zu
  public static void getCircleArea(double r) {
    System.out.println("Die Fläche des Kreises ist" +  r * r * pi);
  }
}

StaticBasic.java

public class StaticBasic {
  public static void main(String[] args) {
    //Die Figur ist von außen zugänglich
    System.out.println(Figure.pi); //3.14
    Figure.getCircleArea(5); //Die Fläche des Kreises beträgt 78.5
  }
}

Einzelne Tonne Muster

• Eine Art Designmuster
• Wird verwendet, wenn Sie nur eine Instanz einer bestimmten ** Klasse erstellen möchten / möchten
• ** Deklariere den Konstruktor als privat **
• Sollte in der App bleiben ** Nur Instanz im Klassenfeld speichern **
• ** Instanz nur einmal zum ersten Mal beim Laden der Klasse **, kann danach nicht mehr instanziiert werden
• Verwenden Sie zum Erfassen der Instanz nur die ** Klassenmethode ** (= Factory-Methode für die Instanzerfassung)
• Als Klassenmitglied definiert, da es zur Verwaltungs- / Generierungsklasse der Instanz selbst gehört

public class MySingleton {

  //Speichern Sie nur die Instanz im Klassenfeld
  private static MySingleton instance = new MySingleton();

  //Deklarieren Sie den Konstruktor als privat
  private MySingleton() {}
  //Lassen Sie die Instanz von der Klassenmethode vorbereiten
  public static MySingleton getInstance() {
    return instance;
  }
}

Klassenkonstante

• ** Konstanten, die direkt unter schreibgeschützten Feldern der Klasse {...} definiert sind **
• ** Füge einfach den letzten Modifikator hinzu **
• cf: konstante Klasse
• Eine Klasse, die die in der gesamten Anwendung verwendeten Konstanten für einen einfachen Zugriff in einer Klasse zusammenfasst (im Wesentlichen zuerst durch die zugehörige Klasse definiert).

public class MyApp {
  public static final String BOOK_TITLE = "Java Master!";
}

public class ConstantBasic {
  public static void main(String[] args) {
    System.out.println(MyApp.BOOK_TITLE); //Java Master!
    //Kann dem letzten Feld nicht zugeordnet werden
    //MyApp.BOOK_TITLE = "Ich werde ein Java-Meister sein!"; //Error
  }
}

statischer Initialisierungsblock

• ** Wird ausgeführt, wenn die Klasse initialisiert wird **
• cf: Initialisierungsblock wird bei der Instanziierung ausgeführt
• Static Initializer
• ** Statischer Modifikator am Anfang des Blocks **
• Wird zum Initialisieren von Klassenmitgliedern verwendet
• Konstanten werden zur Kompilierungszeit in die referenzierende Klasse kopiert
• Wenn der Wert geändert wird, muss auch die konstante Referenzklasse neu kompiliert werden.
• Die Größe der Referrer-Klasse wird etwas größer
• → Durch Initialisieren mit dem statischen Initialisierungsblock können nur ** konstante Werte kopiert werden. Dies ist also eine Lösung! ** ** **

public class Initializer {
  public static final String DOG;
  public static final String CAT;
  public static final String MOUSE;

  static {
    DOG = "inu";
    CAT = "neko";
    MOUSE  = "nezumi";
  }
}

Ausführungsreihenfolge der Initialisierung

** (1) Klasseninitialisierung nur einmal **

• Legen Sie den Standardwert im Klassenfeld fest
• Klassenfeldinitialisierung
• Statische Initialisierungsblockausführung

** (2) Wird jedes Mal ausgeführt, wenn ein Objekt erstellt wird **

• Legen Sie den Standardwert im Instanzfeld fest
• Instanzfeld initialisieren
• Initialisierungsblockausführung
• Konstruktorausführung

//Schlechtes Beispiel
//Der Initialisierungsblock hat Vorrang vor dem Feldinitialisierer
public class Order {
  //Feldinitialisierer
  String value = "First!";
  //Konstrukteur
  public Order() {
    System.out.println(value); //Second!!
  }
  //Der Initialisierungsblock wird vor dem Konstruieren ausgeführt
  {
    value = "Second!!";
  }
}

public class OrderBasic {

  public static void main(String[] args) {
    var o = new Order();
  }
}

Argumentmethode mit variabler Länge

• ** Füge einfach "..." zum Argument hinzu **
• Der empfangene Wert wird als Array betrachtet

public class ArgsParams {
  //Als Argument...Erhalten Sie Argumente mit variabler Länge mit
  public int totalProducts(int... values) {
  // public int totalProducts(int[] values) {
    var result = 1;
    //Argumentwerte, die von extended for empfangen und auf result angewendet werden
    for (var value : values) {
      result *= value;
    }
    return result;
  }
}

public class ArgsParamsBasic {

  public static void main(String[] args) {
    var v = new ArgsParams();
    System.out.println(v.totalProducts(12, 15, -1));
    System.out.println(v.totalProducts(5, 7, 8, 2, 4, 3));

    // System.out.println(v.totalProducts(new int[] {12, 15, -1}));
  }
}

• Hinweis
• ** Eine Methode kann nur am Ende der Argumentliste angegeben werden **
• NG Beispiel * public void hoge(int... x, int y) * public void hoge(int... x, int... y)
• ** Kombinieren Sie erwartete Argumente nicht zu Argumenten variabler Länge **
• Grundsätzlich normale Argumente, variable Länge sammelt nur Informationen, deren Nummer zum Zeitpunkt der Methodendefinition nicht angegeben werden kann
• ** Argumente mit variabler Länge können ein oder mehrere Argumente darstellen **
• Das Argument mit variabler Länge ist ein Argument, das 0 oder mehr Werte erfordert
• Argument mit variabler Länge kann weggelassen werden
• Im Fall von "v.totalProducts ()" wird ein Array der Größe 0 als Argument übergeben
• Wenn mindestens ein Argument angefordert wird Der folgende Code

//Das erste Argument ist eine normale Initiale
//Deklarieren Sie das zweite und nachfolgende Argument mit variabler Länge
//Kompilierungsfehler ohne Argumente
public class ArgsParamsGood {
  public int totalProducts(int initial, int... values) {
    var result = initial;
    for (var value : values) {
      result *= value;
    }
    return result;
  }
}

public class ArgsParamsGoodClient {
  public static void main(String[] args) {
    var v = new ArgsParamsGood();
    System.out.println(v.totalProducts()); //no arguments
  }
}

Argumente und Datentypen

• Der Einflussbereich auf den vom Basistyp und vom Referenztyp übergebenen Wert ist unterschiedlich.

• Grundtyp

public class ParamPrimitive {
  public int update(int num) { //Formelles Argument num
    //Formale Argumente manipulieren
    num *= 10;
    return num;
  }
}

public class ParamPrimitiveBasic {
  public static void main(String[] args) {
    //Variable num
    var num = 2;
    var p = new ParamPrimitive();
    System.out.println(p.update(num)); //20
    //Beeinflusst nicht die ursprüngliche Variable num
    System.out.println(num); //2
  }
}

• Referenztyp
• ** Speicherort im Speicher anstelle von Wert speichern **

public class ParamRef {
  //Kopieren Sie die Referenzadresse der Variablendaten in die formalen Argumentdaten
  public int[] update(int[] data) { //Formale Argumentdaten
    //Manipulation formaler Argumentdaten
    data[0] = 5;
    return data;
  }
}

public class ParamRefBasic {

  public static void main(String[] args) {
    //Aktuelle Argumentdaten
    var data = new int[] { 2, 4, 6 };
    var p = new ParamRef();
    //Im Methodenaufruf wird auf denselben Wert wie das eigentliche Argument und das formale Argument verwiesen.
    System.out.println(p.update(data)[0]); //5
    //Das Bearbeiten der formalen Argumentdaten wirkt sich auf die ursprüngliche Variable aus
    System.out.println(data[0]); //5
  }
}

• Auch bei Referenztyp ** Das Ersetzen des Referenzziels selbst wirkt sich nicht auf die ursprüngliche Variable aus **
• Beispiel: Beim Ersetzen des Arrays

public class ParamRefArray {
  //Das tatsächliche Argument und das formale Argument verweisen zum Zeitpunkt des Methodenaufrufs auf dasselbe
  public int[] update(int[] data) {
    //Wenn ein neues Array zugewiesen wird, ändert sich die Referenzadresse selbst.
    data = new int[] { 10, 20, 30 };
    return data;
  }
}

public class ParamRefArrayBasic {
  public static void main(String[] args) {
    var data = new int[] { 2, 4, 6 };
    var p = new ParamRefArray();
    System.out.println(p.update(data)[0]); //10
    System.out.println(data[0]); //2
  }
}

Nullmaße

import java.util.Map;

public class BookMap {
  //ISBN-Code: Verwalten Sie Buchinformationen nach Buchtitel
  private Map<String, String> data;
  //Initialisieren Sie Buchinformationen mit der Argumentzuordnung
  public BookMap(Map<String, String> map) {
    this.data = map;
  }
  //Erhalten Sie den Titel mit dem ISBN-Code (Argument isbn) als Schlüssel
  public String getTitleByIsbn(String isbn) {
    //Gibt null zurück, wenn der angegebene Schlüssel nicht vorhanden ist
    return this.data.get(isbn);
  }
}

Main.java

import java.util.Map;
public class Main {
  public static void main(String[] args) {
    var b = new BookMap(Map.of(
        "978-4-7981-5757-3", "Stein der Weisen",
        "978-4-7981-5202-8", "Raum der Geheimnisse",
        "978-4-7981-5382-7", "Gefangener von Azkaban"
        ));

    var title = b.getTitleByIsbn("978-4-7981-5757-3");
    if (title == null) {
      System.out.println("Disapparition!(Nicht)");
    } else {
      System.out.println(title.trim()); //Stein der Weisen
    }
  }
}

Vereinfachen Sie den obigen Code mit der optionalen Klasse!

• Umschließen möglicher Nullwerte mit Optinal
• ** Optional.ofNullable Methode **
• Generiere Optional <String> (ein Wert vom Typ String, der null sein kann) basierend auf dem angegebenen Wert!
• Ein Wert vom Typ String, der null sein kann
• ** optTitle.orElse-Methode ** gibt den Wert zurück, wenn das optionale Objekt einen Wert ungleich Null hat, andernfalls den Argumentwert
• → ** Nullsicherheit ** (erzwungene Nullverarbeitung)

import java.util.HashMap;
import java.util.Map;
import java.util.Optional;


public class BookMap {
  private Map<String, String> data = new HashMap<>();

  public BookMap(Map<String, String> map) {
    this.data = map;
  }

  public Optional<String> getTitleByIsbn(String isbn) {
    return Optional.ofNullable(this.data.get(isbn));
  }
}

import java.util.HashMap;

public class OptionalNullCheck {

  public static void main(String[] args) {
    var b = new BookMap(
      new HashMap<String, String>() {
        {
          put("978-4-7981-5757-3", "Stein der Weisen");
          put("978-4-7981-5202-8", "Raum der Geheimnisse");
          put("978-4-7981-5382-7", "Gefangener von Azkaban");
        }
      });

    var optTitle = b.getTitleByIsbn("978-4-7981-5382-7");
    var title = optTitle.orElse("×");
    System.out.println(title.trim()); //Gefangener von Azkaban
  }
}

• Andere optionale Klassenmitglieder
• isPresent / ifPresent: Nullprüfung
• ** orElse / orElseGet: Auf Null prüfen und den Wert erhalten **

import java.util.Optional;

public class OptionalExample {

  public static void main(String[] args) {
    //Optionale Objekterstellung
    var opt1 = Optional.of("Probe 1");
    //Erlaube null
    var opt2 = Optional.ofNullable(null);
    var opt3 = Optional.empty();

    //Bestätigung der Wertexistenz
    System.out.println(opt1.isPresent()); //true
    //Lambda-Ausdrucksausführung, wenn Wert vorhanden ist
    opt1.ifPresent(value -> {
      System.out.println(value); //Probe 1
    });

    //Wenn der Wert von opt2 vorhanden ist, wird sein Wert angezeigt, und wenn er null ist, wird das Argument angezeigt.
    System.out.println(opt2.orElse("Nullwert")); //Nullwert

    //Ausführung des Lambda-Ausdrucks, wenn opt3 null ist
    System.out.println(opt3.orElseGet(() -> {
      return "Nullwert";
    })); //Nullwert
  }
}