[Java] Classe d'objets

Qu'est-ce que la classe Object?

• Une classe qui est implicitement héritée lorsque la clause ** extend est omise dans la déclaration de classe **
• ** Toutes les classes auront finalement la classe Object comme racine **
• Les méthodes de classe d'objets peuvent être utilisées dans toutes les classes (Remplacer dans les classes dérivées si nécessaire)
• ** clone () **: Faire une copie de l'objet
• ** finalize () **: Exécuter lors de la destruction
• Une méthode appelée pour le ramasse-miettes lorsqu'un objet est détruit
  Ce n'est pas garanti et ne doit pas être utilisé dans une vraie application
• ** equals (object obj) **: Est-il égal à l'objet obj?
• ** getClass () **: Récupère la classe de l'objet
• ** hashCode () **: Obtenir le code de hachage
• ** toString () **: Récupère l'objet sous forme de chaîne

méthode toString

• ** Doit être implémenté dans toutes les classes si possible **
• En préparant une représentation de chaîne de caractères appropriée, vous pouvez vérifier le contour de l'objet au moment du test, etc.
• System.out.println (obj);
  // println appelle en interne la méthode toString
• ** Le but est de sélectionner les champs qui caractérisent la classe et de les convertir en chaînes ** (pas le but d'écrire tous les champs)
• Pour faciliter l'utilisation, les informations (champs) utilisées dans toString peuvent être ** préparées et acquises par des getters individuels **

//Implémentation de la méthode toString dans la classe Person
public class Person {
  private String firstName;
  private String lastName;
  public Person(String firstName, String lastName) {
    this.firstName = firstName;
    this.lastName = lastName;
  }

  @Override
  //Sélectionnez les champs qui caractérisent la classe et convertissez-les en chaînes
  public String toString() {
    return String.format("elle est,%s %s.",
        this.lastName, this.firstName);
  }
  //Rendez-le disponible pour les getters individuels
  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); //Elle est Billie Eilish.
  }
}

méthode égale

• Si les objets sont égaux ** Identité ** Jugement
• Si les ** références ** des objets sont les mêmes
• Remplacement de méthode égale requis pour déterminer l'équivalence de sens
• Puisque le contenu est compliqué, implémentons-le uniquement lorsque cela est nécessaire

//firstName/Implémenter la méthode equals dans la classe Person du champ lastName
public class Person {
  private String firstName;
  private String lastName;

  public Person(String firstName, String lastName) {
    this.firstName = firstName;
    this.lastName = lastName;
  }
  //Équivalent si le prénom et le nom sont égaux
  @Override
  public boolean equals(Object obj) {
    //Jugement d'identité
    if (this == obj) {
      return true;
    }
    //Jugement d'équivalence
    //Vérification de type avec instanceof et type cast(Abattu)
    if (obj instanceof Person) {
      var p  = (Person)obj;
      //Égalité de champ de juge(Méthode de la classe String Equals)
      return this.firstName.equals(p.firstName) &&
          this.lastName.equals(p.lastName);
    }
    //False si le type d'argument obj est différent
    return false;
  }
}

Règles à suivre avec égaux

• ** Réfléchissant **: x.equals (x) est vrai
• ** Symétrie **: y.equals (x) est vrai si x.equals (x) est vrai
• ** Faites attention car il a tendance à violer la symétrie **
• ** Transition **: x.equals (z) est vrai si x.equals (x) et y.equals (z) sont vrais
• ** Cohérence **: Si vous ne changez pas en x, y, le résultat vrai / faux ne changera pas même si vous appelez x.equals (y) plusieurs fois.

//Code problématique qui viole la symétrie
public class BusinessPerson extends Person {
  private String department;

//Comparaison de département ajoutée
  public BusinessPerson(String firstName, String lastName, String department) {
    super(firstName, lastName);
    this.department = department;
  }

  @Override
  public boolean equals(Object obj) {
    //identité
    if (this == obj) {
      return true;
    }
    //Équivalence
    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", "Compositeur");
    System.out.println(p.equals(bp));  //true
    System.out.println(bp.equals(p));  //false
  }
}

• problème:
• Dans la méthode equals de la classe Person, ** ignorez le champ title et comparez **, donc p et bp ont la même valeur
• Dans la méthode equals de la classe BusinessPerson, ** p ne peut pas être considéré comme ayant la même valeur car il ne s'agit pas d'un BusinessPerson **
• Ignorer le champ de service et comparer quand l'objet Person est passé à obj
• → La violation de symétrie sera résolue, mais ce sera une violation transitoire (pensez à utiliser la délégation)

//Code problématique qui enfreint la transition
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) {
      //Pour le type BusinessPerson Comparer tous les champs
      if (obj instanceof BusinessPerson) {
        var bp  = (BusinessPerson)obj;
        return super.equals(bp) &&
            this.department.equals(bp.department);
      //Le type de personne ignore le champ de service et compare
      } 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", "Compositeur"); 
    var bp2 = new BusinessPerson("Yumi", "Matsutoya", "chanteur");
    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)); //false Violation transitoire!
  }
}

Obtenir la valeur de hachage de l'objet

• ** Méthode hashCode **
• ** Renvoie la valeur de hachage de l'objet ** (valeur int générée en fonction des données de l'objet)
• Informations pour gérer correctement les valeurs dans les tables de hachage telles que HashMap / HashSet
• ** Les objets équivalents renvoient la même valeur de hachage **
• Si vous remplacez la méthode equals, remplacez également la méthode hashCode
• Si la classe est immuable, au lieu de calculer chaque fois qu'une méthode est appelée, ** cache la valeur de hachage en tant que valeur de champ **

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;

    //Le calcul suivant utilisant la valeur de hachage
    //hash = result*31^(n) + v_1*31^(n-1) +..+ v_n
    //v_1~v_n est la valeur int du champ
    //n est le nombre de champs
    result = prime * result + (boolValue ? 1231 : 1237);
    long temp;
    //La valeur de retour de la méthode doubleToLongBits est un type long
    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;
  }
}

Comparer des objets

• ** méthode compareTo **
• Tri des objets avec la méthode Arrays.sort
• Gestion des clés ordonnées pour TreeMap / TreeSet
• Méthodes qui appartiennent à l'interface Comparable, pas à la classe Object
• En gros, implémentez n'importe quelle classe qui a un sens dans la taille de la valeur
• Implémenté avec Comparable <T>
• <T> est l'objet à comparer
  • Comparable<Person>
• Renvoie une valeur selon les règles suivantes en fonction de la taille
• this> Arguments: ** Entier **
• ceci = argument: ** 0 **
• ce <argument: ** nombre négatif **
• Tout d'abord, comparez la taille avec le champ lastNameKana
• Si égal, comparez la taille avec le champ firstNameKana

//Exemple d'implémentation de la méthode compareTo dans la classe Person
//<Person>L'objet est comparé
//Trier par dictionnaire de noms de famille
public class Person implements Comparable<Person> {
  private String firstNameKana;
  private String lastNameKana;

  public Person(String firstNameKana, String lastNameKana) {
    this.firstNameKana = firstNameKana;
    this.lastNameKana = lastNameKana;
  }
  //Jugement de la taille par nom et prénom kana
  @Override
  //En premier`champ lastNameKana`Comparaison grande et petite
  public int compareTo(Person o) {
    //Si égal`champ firstNameKana`Comparaison grande et petite
    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]
    }
}

Objet dupliqué

• ** méthode de clonage **
• x.clone ()! = x Doit être des références différentes
• x.clone (). getClass () == x.getClass () Correspondance de type
• x.clone (). equals (x) Satisfaire l'équivalence
• Remarque: L'opérateur d'affectation = est une copie de la référence uniquement, pas une copie
  • var x_copy = x;
• ** Copie superficielle **
• ** Interface clonable : Une interface qui n'a aucune signification en soi ( Interface de marqueur **)
• CloneNotSupportedException ne se produit pas tant que l'interface clonable est implémentée
• ** AssertionError **: Une erreur qui indique que le programme se comporte de manière inattendue, ce qui n'est pas possible.

//Implémentez l'interface clonable pour autoriser explicitement la réplication
public class Person implements Cloneable {
  private String firstName;
  private String lastName;

  public Person(String firstName, String lastName) {
    this.firstName = firstName;
    this.lastName = lastName;
  }
  //Faites correspondre la valeur de retour au type de personne au lieu de l'objet d'origine et évitez les problèmes de diffusion côté utilisateur.
  @Override
  public Person clone() {
    Person p = null;
    try {
      //Appelez la méthode clone de la classe Object
      p = (Person)super.clone();
    } catch (CloneNotSupportedException e) {
      throw new AssertionError();
    }
    return p;
  }

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

Copier si le champ contient un type de variable

• ** Copie complète **
• Utilisez la méthode de clonage pour la copie de tableau avec une copie de type de référence
• cf: Nous recommandons les meilleures performances méthode Arrays.copyOf / copyOfRange

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();
      //Dupliquer explicitement un objet tableau en appelant la méthode clone du champ correspondant
      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]);
  }
}