[Java] Objektorientierte Syntaxklasse / Feld / Methode / Bereich

Klasse

• Grundlagen der Java-Anwendung
• Kombinieren von Klassen zum Erstellen einer App

Qualifikation

• Schlüsselwörter, die die Art der Klassen und Mitglieder bestimmen
• Klassenmodifikator
• ** public **: von allen Klassen zugänglich
• ** final **: Vererbung nicht zulassen
• ** abstract **: Abstrakte Klasse
• ** strictfp **: Der Gleitkomma wird umweltunabhängig berechnet

public

• ** Zugriffsqualifizierer **: Auf die aktuelle Klasse können alle Klassen zugreifen
• Wenn nicht angegeben, nur Zugriff vom selben Paket (Paket privat)

strictfp

• Gleitkommazahlen unter dem Operator strictfp werden ** immer vom IEEE754-Standard verarbeitet **
• ** Das gleiche Ergebnis kann unabhängig von der Umgebung erzielt werden! ** **.
• cf: BigDecimal-Klasse, wenn Sie den Fehler des Gleitkommas selbst beseitigen möchten

Klassenstruktur

• Klasse
• Statische Mitglieder
• Klassenfeld
• statischer Initialisierungsblock
• Klassenmethode
• Instanzmitglied
• Feld
• Initialisierungsblock
• Konstrukteur
• Methode

Feld

• Mitgliedsvariablen: Informationen, die von der Klasse verwaltet werden sollen
• Namenskonvention für Variablen
• Zugriff mit .

Person.java

//Name des Zeichenfolgentyps,Definition des Altersfelds vom Typ int
public class Person {
  public String name;
  public int age;
}

Main.java

public class Main {
  public String firstName;
  public String lastName;

  public static void main(String[] args) {
    //Mit neuem Bediener instanziieren
    var p1 = new Person();
    p1.name = "Yamada Taro";
    p1.age = 30;

    var p2 = new Person();
    p2.name = "Ichiro Suzuki";
    p2.age = 25;

    System.out.printf("%s（%d Jahre alt)\n", p1.name, p1.age); //Taro Yamada (30 Jahre alt)
    System.out.printf("%s（%d Jahre alt)\n", p2.name, p2.age); //Ichiro Suzuki (25 Jahre alt)
  }
}

Feldmodifikator

• Allgemein eingeschränkter Zugang mit privatete
• Sie müssen sich bei der Verwendung der Klasse keine Gedanken darüber machen, wie Daten gespeichert werden sollen
• ** public **: Zugriff von allen Klassen
• ** protected **: Auf die aktuelle Klasse und die abgeleitete Klasse kann nur auf dasselbe Paket zugegriffen werden
• ** privat **: Nur über die aktuelle Klasse zugänglich, Standardwert
• ** statisch **: Klassenfeld deklarieren
• ** final **: Neuzuweisung verboten
• ** transient **: Von der Serialisierung ausgeschlossen
• ** flüchtig **: Unterdrückung des Wertecaches

Feld Standard

• Hat einen Standardwert, der vom Datentyp des Feldes abhängt
• Wenn Sie den Standardwert unverändert verwenden, müssen Sie ihn nicht initialisieren, er ist jedoch nicht lesbar.
• cf: Methodendeklarationsvariablen (lokale Variablen) haben keinen Standardwert
  • boolean：false
  • byte, short, int, long：0
  • float, double：0.0
  • char：\u0000
• ** Referenztyp **: null

Methode

• ** Repräsentiert das Verhalten, die Verarbeitung und das Verhalten von Klassen **
• ** Klassendatenwerte (Felder) bearbeiten **
• Hauptmethode: App-Einstiegspunkt, der beim Start automatisch ausgeführt wird
• Andere allgemeine Methoden werden von anderen Methoden mit dem Operator . aufgerufen und ausgeführt.

Person.java

//Methodendefinition anzeigen
public class Person {
  public String name;
  public int age;

  public String show() {
    return String.format("%s（%d).", this.name, this.age);
    //return String.format("%s（%d).", name, age);
  }
}

MethodBasic.java

//p.Greifen Sie mit show auf die Show-Methode zu
public class MethodBasic {

  public static void main(String[] args) {
    var p = new Person();
    p.name = "Yamada Taro";
    p.age = 30;
    System.out.println(p.show());
  }
}

Methodenargument

• ** Tatsächliches Argument **: Vom Anrufer übergeben
• ** Formales Argument **: Empfängervariable
• Nur innerhalb der Methode zugänglich (lokale Variable)

//Tatsächliches Argument
getBmi(60,1.7)

//Formelles Argument
public double GetBmi {double weight, double height){
    return  weight / (height * height )
}

• Wenn es viele Argumente gibt, ** gruppieren Sie verwandte Argumente in einer Klasse **
• Argumentreihenfolge
• Von den wichtigen
• Konsistenz in Ordnung
• Verwandte Argumente sind nah

Rückgabewert der Methode

• Geben Sie das Verarbeitungsergebnis mit return zurück
• Anweisungen nach der Rücksendung werden nicht ausgeführt
• Optional, wenn kein Rückgabewert vorhanden ist. ** Geben Sie viod als Methodendefinitionstyp an. **
• Die void-Methode kann den Prozess auch explizit mit return; an den Aufrufer zurückgeben

Person.java

public class Person {
  public String name;
  public int age;

  public void show() {
    System.out.printf("%s（%d).\n", this.name, this.age);
  }
}

MethodVoid.java

public class MethodVoid {

  public static void main(String[] args) {
    var p = new Person();
    p.name = "Yamada Taro";
    p.age = 30;
    p.show();
  }
}

Methodenmodifikator

• Sie müssen sich keine Gedanken darüber machen, wie Daten gespeichert werden, wenn Sie eine Klasse mit einem Modifikator verwenden.
• ** public **: Zugriff von allen Klassen
• ** protected **: Auf die aktuelle Klasse und die abgeleitete Klasse kann nur auf dasselbe Paket zugegriffen werden
• ** privat **: Nur über die aktuelle Klasse zugänglich, Standardwert
• ** static **: Klassenmethode deklarieren
• ** abstract **: Deklarieren Sie eine abstrakte Methode
• ** final **: Überschreiben verboten
• ** synchronisiert **: Nur von einem Thread aus zugänglich
• ** strictfp **: Berechnen Sie den Gleitkomma so, dass er unabhängig von der Umgebung ist
• ** native **: Methode, die in einer anderen Sprache als Java (C / C ++) geschrieben wurde * public final native void notify();
• Es gibt auch Nachteile wie das Vorhandensein von Overhead und eine kompliziertere Quellverwaltung als Java allein.

this

• ** Zeigen Sie auf das aktuelle Objekt **
• Variablen, die implizit unter der Methode verwendet werden können
• Siehe das Feld Name / Alter des aktuellen Objekts
  System.out.printf ("% s (% d Jahre alt). \ N ", this.name, this.age);
• Methodenreferenz
  this.myMethod (…)
• Ob dies geschrieben werden soll
• Für Felder ** Verwenden Sie diese Option, um zwischen gleichnamigen lokalen Variablen zu unterscheiden, wenn diese abgedeckt sind **
• Es scheint besser zu sein, dies allen Feldern hinzuzufügen **, damit Sie nicht nacheinander beurteilen müssen, ob es lokale Variablen gibt **
• Verwenden Sie diese Option, wenn die Methode ** angeben möchte, dass sie zum aktuellen Objekt gehört **

Methodenüberladung

• Überladung: ** Definieren Sie mehrere Methoden mit demselben Namen, aber unterschiedlichen Argumenttypen / -sequenzen **
• Nicht möglich, wenn der Rückgabetyp / Argumentname unterschiedlich ist
• Grundsätzlich dürfen Felder mit demselben Namen nicht in derselben Klasse vorhanden sein
• Die Methode ist jedoch durch ** Signatur (Name, Argumenttyp, Sequenz) ** gekennzeichnet, sodass sie nur zulässig ist, wenn Folgendes unterschiedlich ist:
• Anzahl der Argumente
• Argument Datentyp
• Unterschrift
• Die Signatur von "int indexOf (String str, int index)" ist
  • indexOf( String , int )
• Überlastung
  • public static int abs( int a )
  • public static float abs( float a )
• Wird beim Aufrufen der ursprünglichen Überladung verwendet, indem nur der angegebene Wert des Arguments mit einer Überladung vorbereitet wird
• Hinweis: Das Überladen mit der gleichen Anzahl von Argumenten, aber unterschiedlichen Typen ist nicht gut
• Überladung wird zur Kompilierungszeit und nicht zur Laufzeit ausgewählt
• Wenn der folgende Code ausgeführt wird, wird nur die "public void show" (CharSequence cs) {"des for-Schleifentyps" CharSequence "ausgeführt.

//Erwarten Sie je nach Typ eine optimale Überlastung
//Aber das Ergebnis ist
//Zeichenfolge: Der Frühling ist Akebono
//CharSequence: Sommer ist Nacht
//CharSequence: Abenddämmerung im Herbst
public class OverloadAnti {

  public void show(String value) {
    System.out.println("String: " + value);
  }

  public void show(StringBuilder builder) {
    System.out.println("StringBuilder：" + builder);
  }
  public void show (StringBuffer buf) {
    System.out.println("StringBuffer：" + buf);
  }
  public void show(CharSequence cs) {
    System.out.println("CharSequence：" + cs);
  }
}

public class OverloadAntiClient {

  public static void main(String[] args) {
    var c = new OverloadAnti();
    var list = new CharSequence[] {
        "Der Frühling ist Akebono",
        new StringBuilder("Sommer ist Nacht"),
        new StringBuffer("Der Herbst ist Abenddämmerung"),
    };

    for (var cs : list) {
      c.show(cs);
    }
  }
}

Umfang

• ** Umfang der Variablen im Code **
• Bestimmen Sie, wo auf die Variable verwiesen werden kann
• Hängt davon ab, wo die Variable deklariert ist
• ** Feldumfang **
• Direkt unter Klasse deklariert {…}
• Zugänglich für die gesamte Klasse
• ** Bereich der lokalen Variablen **
• Im Methodendefinitionsblock deklariert
• Nur innerhalb der Methode zugänglich
• ** Geltungsbereich blockieren **
• Eine Art lokaler Variable
• Deklaration unter Methode (Kontrollblock wie if / while / for)
• Nur innerhalb des Blocks zugänglich

Konflikt zwischen Feld und lokaler Variable

• Wenn eine gleichnamige Variable innerhalb oder außerhalb der Methode deklariert wird
• ** Variablen mit unterschiedlichen Bereichen (Feldvariablen, lokale Variablen) haben den gleichen Namen, sind aber unterschiedlich! !! ** **.
• Verwenden Sie ** diese **, wenn Sie auf versteckte Feldvariablen zugreifen möchten

Scop.java

//Daten werden abgedeckt
public class Scope {
    //Daten als Feldvariable
  public String data = "Feld";

  public String show() {
    //Daten als lokale Variable
    //Wenn Sie dies deklarieren, werden vorübergehend Feldvariablen ausgeblendet, die für die gesamte Klasse gültig sein sollten
    var data = "lokal";
    return data;
    //Wenn Sie auf versteckte Feldvariablen zugreifen möchten
    // return this.data;
  }
}

ScopeBasic.java

public class ScopeBasic {

  public static void main(String[] args) {
    var s = new Scope();  
    //Lokale Variablen der show-Methode
    System.out.println(s.show()); //lokal
    //Lokale Variablen wirken sich nicht auf Feldvariablen aus
    System.out.println(s.data); //Feld
  }
}

• ** Hinweis: Der Gültigkeitsbereich der Variablen reicht von der deklarierten Position bis zum Ende des Blocks **
• Variable ist ab der deklarierten Position gültig

//NG Beispiel: str1 ist ab der deklarierten Position gültig
public class ScopeStrict {
  String str2 = str1; //Str2 kann nicht vor str1 deklariert werden
  String str1 = “neko desu“;
}

• ** Ausnahmen zu Referenzen von Methoden / Konstruktoren **
• Unabhängig von der Deklarationsposition ** Kann aus der gesamten Klasse referenziert werden **
• Kann nur von Methode / Konstruktor (Initialisierungsblock usw.) referenziert werden.)

public class ScopeStrict {
  public void show() {
    System.out.println(str); //neko desu
  }
  String str = “neko desu”;
}

StrictClient.java

public class StrictClient {
  public static void main(String[] args) {
    var s = new ScopeStrict();
    s.show();
  }
}

Bereich blockieren

• Mit Steuerungssyntax deklarierte Variablen (z. B. if / while / for / try)
• Da es sich um eine lokale Variable handelt, ** kann eine Blockbereichsvariable mit demselben Namen wie die obere lokale Variable nicht deklariert werden **
• Es ist möglich, eine lokale Variable mit demselben Namen zu deklarieren, nachdem eine Blockvariable zerstört wurde
• Die Deklaration von Blockbereichsvariablen ist auch mit parallelen Blöcken möglich

public class ScopeBlock {
  public static void main(String[] args) {
    /*
    //Deklarieren Sie eine Blockbereichsvariable mit demselben Namen wie die lokale Variable
    var data = "Lokaler Bereich";
    {
      var data = "Bereich blockieren"; //Error
    }
    */

    {
      var data = "Bereich blockieren";
    }
    //Zu diesem Zeitpunkt wurde die Blockbereichsvariable zerstört
    var data = "Lokaler Bereich"; //OK
    System.out.println(data);
  }
}

//Paralleler Blockumfang
public class ScopeBlock {

  public static void main(String[] args) {
    {
      var data = "Bereich blockieren";
      System.out.println(data);
    }

    {
      var data = "Blockbereich 2";
      System.out.println(data);
    }
  }
}