[Java] Objektklasse

Was ist die Objektklasse?

• Eine Klasse, die implizit geerbt wird, wenn die ** Extended-Klausel in der Klassendeklaration weggelassen wird **
• ** Alle Klassen haben schließlich die Object-Klasse als Root **
• Objektklassenmethoden können in allen Klassen verwendet werden (ggf. in abgeleiteten Klassen überschreiben)
• ** clone () **: Erstellen Sie eine Kopie des Objekts
• ** finalize () **: Wird beim Zerstören ausgeführt
• Eine Methode, die für die Speicherbereinigung aufgerufen wird, wenn ein Objekt zerstört wird.
  Sie ist nicht garantiert und sollte nicht in einer echten App verwendet werden
• ** gleich (Objekt obj) **: Ist es gleich dem Objekt obj?
• ** getClass () **: Ruft die Klasse des Objekts ab
• ** hashCode () **: Hash-Code abrufen
• ** toString () **: Objekt als Zeichenfolge abrufen

toString-Methode

• ** Sollte wenn möglich in allen Klassen implementiert werden **
• Durch Vorbereiten einer geeigneten Zeichenfolgendarstellung können Sie den Umriss des Objekts zum Zeitpunkt des Tests usw. überprüfen.
• System.out.println (obj);
  // println ruft intern die toString-Methode auf
• ** Der Punkt ist, die Felder auszuwählen, die die Klasse charakterisieren, und sie in Zeichenfolgen umzuwandeln ** (nicht der Zweck, alle Felder zu schreiben)
• Zur Vereinfachung der Verwendung können in toString verwendete Informationen (Felder) ** von einzelnen Gettern ** vorbereitet und erfasst werden **

//Implementierte toString-Methode in der Person-Klasse
public class Person {
  private String firstName;
  private String lastName;
  public Person(String firstName, String lastName) {
    this.firstName = firstName;
    this.lastName = lastName;
  }

  @Override
  //Wählen Sie die Felder aus, die die Klasse charakterisieren, und konvertieren Sie sie in Zeichenfolgen
  public String toString() {
    return String.format("Sie ist,%s %s.",
        this.lastName, this.firstName);
  }
  //Stellen Sie es einzelnen Gettern zur Verfügung
  public String getLastName() {
    return this.lastName;
  }
  public String getFirstName() {
    return this.firstName;
  }
}

public class ToStringBasic {
  public static void main(String[] args) {
    var p = new Person("Eilish", "Billie");
    System.out.println(p); //Sie ist Billie Eilish.
  }
}

entspricht Methode

• Ob Objekte gleich sind ** Identität ** Beurteilung
• Ob die ** Referenzen ** der Objekte gleich sind
• Gleiche Methodenüberschreibung erforderlich, um die Äquivalenz der Bedeutung zu bestimmen
• Da der Inhalt kompliziert ist, implementieren wir ihn nur bei Bedarf

//firstName/Implementieren Sie die Methode equals in der Klasse Person des Felds lastName
public class Person {
  private String firstName;
  private String lastName;

  public Person(String firstName, String lastName) {
    this.firstName = firstName;
    this.lastName = lastName;
  }
  //Gleichwertig, wenn Vor- und Nachname gleich sind
  @Override
  public boolean equals(Object obj) {
    //Beurteilung der Identität
    if (this == obj) {
      return true;
    }
    //Beurteilung der Gleichwertigkeit
    //Typprüfung mit instanceof und type cast(Niedergeschlagen)
    if (obj instanceof Person) {
      var p  = (Person)obj;
      //Beurteilung der Feldgleichheit(String-Klasse entspricht Methode)
      return this.firstName.equals(p.firstName) &&
          this.lastName.equals(p.lastName);
    }
    //False, wenn die Art des Arguments obj unterschiedlich ist
    return false;
  }
}

Regeln, die mit Gleichheit zu befolgen sind

• ** Reflective **: x.equals (x) ist wahr
• ** Symmetrie **: y.equals (x) ist wahr, wenn x.equals (x) wahr ist
• ** Seien Sie vorsichtig, da dies dazu neigt, die Symmetrie zu verletzen **
• ** Übergang **: x.equals (z) ist wahr, wenn x.equals (x) und y.equals (z) wahr sind
• ** Konsistenz **: Wenn Sie nicht zu x, y wechseln, ändert sich das True / False-Ergebnis auch dann nicht, wenn Sie x.equals (y) mehrmals aufrufen.

//Problematischer Code, der die Symmetrie verletzt
public class BusinessPerson extends Person {
  private String department;

//Abteilungsvergleich hinzugefügt
  public BusinessPerson(String firstName, String lastName, String department) {
    super(firstName, lastName);
    this.department = department;
  }

  @Override
  public boolean equals(Object obj) {
    //Identität
    if (this == obj) {
      return true;
    }
    //Gleichwertigkeit
    if (obj instanceof BusinessPerson) {
      var bp = (BusinessPerson)obj;
      return super.equals(bp) &&
          this.department.equals(bp.department);
    }
    return false;
  }
}

public class EqualsBasic {
  public static void main(String[] args) {
    var p = new Person("Yumi", "Matsutoya");
    var bp = new BusinessPerson("Yumi", "Matsutoya", "Komponist");
    System.out.println(p.equals(bp));  //true
    System.out.println(bp.equals(p));  //false
  }
}

• Problem:
• In der Methode equals der Person-Klasse ** ignorieren Sie das Titelfeld und vergleichen Sie **, sodass p und bp den gleichen Wert haben
• In der Methode equals der BusinessPerson-Klasse kann ** p nicht als der gleiche Wert angesehen werden, da es sich nicht um eine BusinessPerson handelt **
• Abteilungsfeld ignorieren und vergleichen, wenn das Personenobjekt an obj übergeben wird
• → Die Symmetrieverletzung wird behoben, es handelt sich jedoch um eine Übergangsverletzung (Verwendung einer Delegierung in Betracht ziehen).

//Problematischer Code, der den Übergang verletzt
public class BusinessPerson extends Person {
  private String department;

  public BusinessPerson(String firstName, String lastName, String department) {
    super(firstName, lastName);
    this.department = department;
  }

  @Override
  public boolean equals(Object obj) {
    if (this == obj) {
      return true;
    }

    if (obj instanceof Person) {
      //Geben Sie für BusinessPerson alle Felder vergleichen ein
      if (obj instanceof BusinessPerson) {
        var bp  = (BusinessPerson)obj;
        return super.equals(bp) &&
            this.department.equals(bp.department);
      //Personentyp ignoriert Abteilungsfeld und vergleicht
      } else {
        return super.equals(obj);
      }
    }
    return false;
  }
}

public class EqualsBasic {
  public static void main(String[] args) {
    var p = new Person("Yumi", "Matsutoya");
    var bp1 = new BusinessPerson("Yumi", "Matsutoya", "Komponist"); 
    var bp2 = new BusinessPerson("Yumi", "Matsutoya", "Sänger");
    System.out.println(bp1.equals(p)); //true
    System.out.println(p.equals(bp1)); //true
    System.out.println(p.equals(bp2)); //true
    System.out.println(bp1.equals(bp2)); //falsche Übergangsverletzung!
  }
}

Hash-Wert des Objekts abrufen

• ** hashCode Methode **
• ** Gibt den Objekt-Hash-Wert zurück ** (int-Wert, der basierend auf den Objektdaten generiert wurde)
• Informationen zum korrekten Verwalten von Werten in Hash-Tabellen wie HashMap / HashSet
• ** Äquivalente Objekte geben denselben Hashwert zurück **
• Wenn Sie die equals-Methode überschreiben, überschreiben Sie auch die hashCode-Methode
• Wenn die Klasse unveränderlich ist, speichern Sie den Hash-Wert als Feldwert, anstatt jedes Mal zu berechnen, wenn eine Methode aufgerufen wird.

public class ObjectHash {
  private boolean boolValue;
  private int intValue;
  private long longValue;
  private float floatValue;
  private double doubleValue;
  private String stringValue;
  @Override
  public int hashCode() {
    final int prime = 31;
    int result = 1;

    //Die folgende Berechnung unter Verwendung des Hashwerts
    //hash = result*31^(n) + v_1*31^(n-1) +..+ v_n
    //v_1~v_n ist der int-Wert des Feldes
    //n ist die Anzahl der Felder
    result = prime * result + (boolValue ? 1231 : 1237);
    long temp;
    //Der Rückgabewert der doubleToLongBits-Methode ist ein langer Typ
    temp = Double.doubleToLongBits(doubleValue);
    result = prime * result + (int) (temp ^ (temp >>> 32));
    result = prime * result + Float.floatToIntBits(floatValue);
    result = prime * result + intValue;
    result = prime * result + (int) (longValue ^ (longValue >>> 32));
    result = prime * result + ((stringValue == null) ? 0 : stringValue.hashCode());
    return result;
  }
  @Override
  public boolean equals(Object obj) {
    if (this == obj)
      return true;
    if (obj == null)
      return false;
    if (getClass() != obj.getClass())
      return false;
    ObjectHash other = (ObjectHash) obj;
    if (boolValue != other.boolValue)
      return false;
    if (Double.doubleToLongBits(doubleValue) != Double.doubleToLongBits(other.doubleValue))
      return false;
    if (Float.floatToIntBits(floatValue) != Float.floatToIntBits(other.floatValue))
      return false;
    if (intValue != other.intValue)
      return false;
    if (longValue != other.longValue)
      return false;
    if (stringValue == null) {
      if (other.stringValue != null)
        return false;
    } else if (!stringValue.equals(other.stringValue))
      return false;
    return true;
  }
}

Objekte vergleichen

• ** compareTo Methode **
• Sortieren von Objekten mit der Arrays.sort-Methode
• Bestellte Schlüsselverwaltung für TreeMap / TreeSet
• Methoden, die zur Schnittstelle Comparable gehören, nicht zur Object-Klasse
• Implementieren Sie grundsätzlich jede Klasse, die eine Bedeutung für die Größe des Werts hat
• Implementiert mit Comparable <T>
• <T> ist das zu vergleichende Objekt
  • Comparable<Person>
• Gibt einen Wert gemäß den folgenden Regeln entsprechend der Größe zurück
• this> Argumente: ** Integer **
• this = Argument: ** 0 **
• dieses <Argument: ** negative Zahl **
• Vergleichen Sie zuerst die Größe mit dem Feld lastNameKana
• Wenn gleich, vergleiche Größe mit firstNameKana field

//Beispiel für die Implementierung der compareTo-Methode in der Person-Klasse
//<Person>Objekt wird verglichen
//Sortieren nach Nachnamen Wörterbuch
public class Person implements Comparable<Person> {
  private String firstNameKana;
  private String lastNameKana;

  public Person(String firstNameKana, String lastNameKana) {
    this.firstNameKana = firstNameKana;
    this.lastNameKana = lastNameKana;
  }
  //Beurteilung der Größe nach Nachname und Name Kana
  @Override
  //Zunaechst`Feld lastNameKana`Großer und kleiner Vergleich
  public int compareTo(Person o) {
    //Wenn gleich`Feld firstNameKana`Großer und kleiner Vergleich
    if (this.lastNameKana.equals(o.lastNameKana)) {
      return this.firstNameKana.compareTo(o.firstNameKana);
    } else {
      return this.lastNameKana.compareTo(o.lastNameKana);
    }
  }

  @Override
  public String toString() {
    return this.lastNameKana + " " + this.firstNameKana;
  }
}

import java.util.Arrays;
import java.util.Arrays;

public class CompareBasic {
    public static void main(String[] args) {
        var data = new Person[] {
                new Person("Harry", "Potter"),
                new Person("Ron", "Weasley"),
                new Person("Hermione", "Granger"),
                new Person("Albus", "Dumbledore"),
                new Person("Severus", "Snape"),
                new Person("Serius", "Black"),
        };
        Arrays.sort(data);
        System.out.println(Arrays.toString(data));
        //[Black Serius, Dumbledore Albus, Granger Hermione, Potter Harry, Snape Severus, Weasley Ron]
    }
}

Objekt duplizieren

• ** Klonmethode **
• x.clone ()! = x Muss unterschiedliche Referenzen sein
• x.clone (). getClass () == x.getClass () Typ match
• x.clone (). entspricht (x) Erfüllen Sie die Äquivalenz
• Hinweis: Der Zuweisungsoperator = ist nur eine Kopie der Referenz, kein Duplikat
  • var x_copy = x;
• ** Flache Kopie **
• ** Klonbare Schnittstelle : Eine Schnittstelle, die an sich keine Bedeutung hat ( Marker-Schnittstelle **)
• CloneNotSupportedException tritt nicht auf, solange die klonbare Schnittstelle implementiert ist
• ** AssertionError **: Ein Fehler, der anzeigt, dass sich das Programm unerwartet verhält, was nicht möglich ist.

//Implementieren Sie die klonbare Schnittstelle, um die Replikation explizit zuzulassen
public class Person implements Cloneable {
  private String firstName;
  private String lastName;

  public Person(String firstName, String lastName) {
    this.firstName = firstName;
    this.lastName = lastName;
  }
  //Passen Sie den Rückgabewert an den Personentyp anstelle des ursprünglichen Objekts an und sparen Sie sich das Casting auf der Benutzerseite
  @Override
  public Person clone() {
    Person p = null;
    try {
      //Rufen Sie die Klonmethode der Object-Klasse auf
      p = (Person)super.clone();
    } catch (CloneNotSupportedException e) {
      throw new AssertionError();
    }
    return p;
  }

  @Override
  public String toString() {
    return this.lastName + this.firstName;
  }
}

Kopieren, wenn das Feld einen Variablentyp enthält

• ** Tiefe Kopie **
• Verwenden Sie die Klonmethode für die Array-Kopie mit Referenzkopie
• cf: Die leistungsstärkere Methode "Arrays.copyOf / copyOfRange" wird empfohlen

public class Person implements Cloneable {
  private String firstName;
  private String lastName;
  private String[] memos;

  public Person(String firstName, String lastName, String[] memos) {
    this.firstName = firstName;
    this.lastName = lastName;
    this.memos = memos;
  }

  @Override
  public Person clone() {
    Person p = null;
    try {
      p = (Person) super.clone();
      //Duplizieren Sie ein Array-Objekt explizit, indem Sie die Klonmethode des entsprechenden Felds aufrufen
      p.memos = this.memos.clone();
    } catch (CloneNotSupportedException e) {
      throw new AssertionError();
    }
    return p;
  }

  @Override
  public String toString() {
    return  String.format("%s%s（%s）",
        this.lastName, this.firstName, this.memos[1]);
  }
}