J'apprends le polymorphisme Java dans VScode (polymorphisme Java, instanceof, méthode de détection d'égalité d'objet [détection getClass() d'égalité de sous-classe, détection instanceof de concept d'égalité de super classe))

News 2023-08-26 01:46:27 views: null 
Java的多态（Polymorphism）是面向对象编程中的一种特性，它允许不同的对象能够以统一的方式进行访问和操作。
	它允许一个类的实例在运行时表现出多种形态。
Java多态的实现主要依赖于两个基本概念：继承和方法重写。

En Java, une sous-classe peut hériter des méthodes de la classe parent et implémenter son propre comportement spécifique en remplaçant ces méthodes. Lorsque nous créons un objet, il peut pointer vers son propre type de classe, ou vers n'importe quelle classe parent ou type d'interface implémenté. C'est l'idée centrale du polymorphisme Java : un objet peut avoir plusieurs apparences et comportements, selon le contexte dans lequel il est utilisé.

L'avantage du polymorphisme Java est qu'il peut améliorer la réutilisabilité et la maintenabilité du code, le rendant ainsi plus flexible et extensible. Par exemple, une méthode peut accepter une classe de base (telle que Object) comme paramètre, puis transmettre une instance d'une sous-classe au moment de l'exécution, afin que différents types d'objets puissent être gérés sans réécrire la méthode.

Annuaire d'articles

父类引用引用一个具有子类身份信息的对象时，就创建了一个多态关系的实现效果。

En Java, le polymorphisme peut être implémenté de deux manières :

Parent obj = new Child();
obj.show(); // 调用子类的方法

表现出多态度的过程：多态性的优点在于它增加了代码的灵活性和可扩展性，使得代码更易于维护和重用。

  1. Polymorphisme au moment de la compilation : également connu sous le nom de polymorphisme statique, implémenté via une surcharge de méthode. La surcharge de méthodes fait référence à la définition de plusieurs méthodes portant le même nom dans une classe, mais avec des listes de paramètres différentes. Le compilateur choisira la méthode à appeler en fonction du type de paramètres transmis.

  2. Polymorphisme d'exécution : également connu sous le nom de polymorphisme dynamique, implémenté par réécriture de méthodes. La réécriture de méthode signifie que la sous-classe redéfinit la méthode avec le même nom et la même liste de paramètres dans la classe parent, et que l'objet de la sous-classe appellera la méthode correspondante en fonction du type d'objet spécifique au moment de l'exécution.

Une brève description:父类类型 类型名称 = 子类对象

L'implémentation du polymorphisme d'exécution doit répondre aux conditions suivantes :

  • Il existe une relation d'héritage : la classe enfant hérite de la classe parent.
  • Il existe une substitution de méthode : la sous-classe remplace la méthode de la classe parent.
  • La référence de la classe parent pointe vers l'objet de la sous-classe : la référence de la classe parent pointe vers l'objet de la sous-classe, et la méthode correspondante sera appelée en fonction du type de l'objet réel au moment de l'exécution.

détaillé:

  1. L'établissement de la relation entre la classe parent et la classe enfant :

    class Parent {
      
      
    void show() {
      
      
        System.out.println("Parent's show method");
    }
}

class Child extends Parent {
      
      
    void show() {
      
      
        System.out.println("Child's show method");
    }
}

  2. Lors de l'utilisation du polymorphisme :

    Parent obj1 = new Parent();
Parent obj2 = new Child();

obj1.show(); // 调用父类的方法
obj2.show(); // 调用子类的方法

  3. Réécriture de méthode (Override) :

    @Override
void show() {
      
      
    System.out.println("Child's overridden show method");
}

  4. La référence de classe parent appelle la méthode de sous-classe :

    Parent obj = new Child();
obj.show(); // 调用子类的方法

Le moment d'utiliser le polymorphisme en Java se situe généralement dans le contexte de la programmation orientée objet, notamment dans les situations suivantes :

  1. Relation d'héritage : lorsque plusieurs classes ont une relation d'héritage, leurs objets peuvent être traités par polymorphisme, obtenant ainsi une structure de code plus flexible et simplifiant la logique du code.

  2. Paramètres de méthode : si une méthode doit recevoir différents types d'objets et effectuer des opérations similaires sur eux, l'utilisation du polymorphisme peut rendre le code plus général et plus facile à développer.

  3. La valeur de retour de la méthode : lorsque le type de retour de la méthode est la classe de base ou le type d'interface, mais que le retour réel est une instance de la classe dérivée, le polymorphisme peut être utilisé pour y parvenir.

  4. Utilisation de collections : lors de l'utilisation de collections (telles que List, Set, Map), le polymorphisme peut être utilisé pour stocker différents types d'objets et les opérations peuvent être effectuées via une interface unifiée.

En général, le polymorphisme rend le code plus flexible et plus maintenable, et peut améliorer la réutilisabilité et l'évolutivité du code.

Pour réaliser le polymorphisme en Java, les points suivants sont requis :

0. Autre :

  1. Upcasting : attribuez l'objet de sous-classe à la référence de classe parent. Cela active le polymorphisme, mais seules les méthodes définies dans la classe parent peuvent être appelées.
  2. Downcasting : convertissez les références de classe parent en objets de sous-classe. Un casting est requis pour la conversion. Cependant, il convient de noter que le downcast peut provoquer une ClassCastException, donc une vérification de type (à l'aide de instanceof) est requise avant le cast.

1. Relation successorale (création de classes parents et enfants) :

Tout d’abord, vous devez concevoir une classe parent (classe de base), qui contient certaines propriétés et méthodes communes. Créez ensuite une ou plusieurs sous-classes (classes dérivées), qui héritent des propriétés et méthodes de la classe parent et peuvent ajouter leurs propres propriétés et méthodes spécifiques.

class Shape {
    
    
    void draw() {
    
    
        System.out.println("Drawing a shape");
    }
}

class Circle extends Shape {
    
    
    @Override
    void draw() {
    
    
        System.out.println("Drawing a circle");
    }
}

class Rectangle extends Shape {
    
    
    @Override
    void draw() {
    
    
        System.out.println("Drawing a rectangle");
    }
}

2. Réécriture de méthode (Override) :

Dans les sous-classes, vous pouvez utiliser @Overridedes annotations pour remplacer les méthodes de la classe parent. Assurez-vous que les méthodes remplacées ont la même signature de méthode (nom, liste de paramètres et type de retour) pour fonctionner en polymorphisme.

3. Référence de classe parent et objet de sous-classe :

Utiliser la variable de référence de la classe parent pour faire référence à l'objet de la sous-classe est la clé du polymorphisme. Cela vous permet de conserver une flexibilité lors du codage et de décider quelle méthode de classe appeler au moment de l'exécution.

Shape myShape1 = new Circle();//`Shape` 是父类引用，而 `new Circle();` 是子类对象。
Shape myShape2 = new Rectangle();

myShape1.draw(); // 输出：Drawing a circle
myShape2.draw(); // 输出：Drawing a rectangle

Le polymorphisme nous permet d'utiliser des références de classe parent pour faire référence à des objets de sous-classe, car les objets de sous-classe peuvent être affectés à des références de classe parent. Cela facilite la flexibilité et l’évolutivité du code.

Dans Shape myShape1 = new Circle(); cette ligne de code, nous créons un Circleobjet de classe et l'attribuons à Shapeune variable de référence de type myShape1. Cette affectation est légale car Circle il s'agit d'une sous-classe de . ShapeCela signifie que même si myShape1le type de est Shape, ce qu'il pointe est en réalité un Circle objet de type .

De cette manière, nous pouvons utiliser une référence Shape commune pour faire référence à différents objets de forme concrets, réalisant ainsi les concepts de polymorphisme et d'héritage. Ce design pattern nous permet de manipuler les objets de manière plus abstraite dans notre code, tout en conservant les fonctionnalités spécifiques des objets concrets.

4. Liaison d'exécution (polymorphisme d'exécution) :

Lorsqu'une méthode est invoquée via une référence de classe parent, Java détermine dynamiquement la méthode réelle à appeler au moment de l'exécution, c'est ce qu'on appelle la liaison d'exécution. Cela signifie que vous pouvez utiliser le même appel de méthode dans différents contextes, mais en réalité exécuter des méthodes de différentes sous-classes.

5. Utilisez une classe ou une interface abstraite (facultatif) :

Si vous souhaitez définir un ensemble partagé de signatures de méthodes, utilisez une classe ou une interface abstraite. Une classe abstraite peut fournir une implémentation partielle, tandis qu'une interface impose l'implémentation de toutes les méthodes. Cela rend le polymorphisme plus flexible, permettant de partager davantage de comportements entre différentes classes.

interface Sound {
    
    
    void makeSound();
}

class Dog implements Sound {
    
    
    @Override
    public void makeSound() {
    
    
        System.out.println("Dog barks");
    }
}

class Cat implements Sound {
    
    
    @Override
    public void makeSound() {
    
    
        System.out.println("Cat meows");
    }
}

Pour résumer, l'implémentation du polymorphisme nécessite la création de relations d'héritage, le remplacement de méthodes, l'utilisation de références de superclasse et d'objets de sous-classe, une liaison d'exécution et éventuellement des classes ou interfaces abstraites. Ensemble, ces concepts font du polymorphisme une fonctionnalité puissante dans la programmation orientée objet, augmentant la flexibilité et la maintenabilité du code.

Caractéristiques des membres d'appel polymorphes

Appel de variable : regardez le côté gauche lors de la compilation et regardez le côté gauche lors de l'exécution.
Appel de méthode : regardez le côté gauche lors de la compilation et regardez le côté droit lors de l'exécution.

  1. Lorsqu'une variable appelle un membre, le membre accessible sera déterminé au moment de la compilation en fonction du type déclaré de la variable (à gauche), et le type réel de la variable (à gauche) sera utilisé au moment de l'exécution pour déterminer le code réellement exécuté.

     编译时看左边： 在编译阶段，编译器会检查父类中是否存在被调用的成员变量。
 	如果存在，编译通过；如果不存在，编译失败。
 运行时也看左边： 在运行阶段，程序实际获取的是左边父类中的成员变量的值，而不考虑实际对象的类型。

  2. Lorsqu'une méthode est appelée, la méthode qui peut être appelée sera déterminée en fonction du type déclaré de la variable (côté gauche) au moment de la compilation, mais la méthode réelle à exécuter sera déterminée en fonction du type de l'objet réel ( côté droit) au moment de l’exécution.

     编译时看左边： 在编译阶段，编译器会检查变量的声明类型（左边）来确定可调用的方法。
 	如果左边的类型没有声明被调用的方法，编译会报错，即使实际对象具有相应的方法。
 运行时看右边： 在运行阶段，方法调用会根据实际对象的类型（右边）来决定实际执行的方法。
 	即使使用父类的引用，程序也会根据实际对象的类型来调用相应的方法，这被称为动态方法分派。

Ce comportement vous permet d'implémenter différents comportements en remplaçant les instances d'objet au moment de l'exécution, ce qui est un concept clé du polymorphisme.

class Animal {
    
    
    public void makeSound() {
    
    
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    
    
    @Override
    public void makeSound() {
    
    
        System.out.println("Dog barks");
    }
}

class Cat extends Animal {
    
    
    @Override
    public void makeSound() {
    
    
        System.out.println("Cat meows");
    }
}

public class Main {
    
    
    public static void main(String[] args) {
    
    
        Animal myAnimal1 = new Dog();  // 编译看左边，运行也看左边
        Animal myAnimal2 = new Cat();  // 编译看左边，运行也看左边

        myAnimal1.makeSound();  // 编译看左边，运行看右边 ("Dog barks")
        myAnimal2.makeSound();  // 编译看左边，运行看右边 ("Cat meows")
    }
}

insérer la description de l'image ici

instanceof convertit l'objet en classe spécifiée une fois le jugement correspondant réussi

使用 instanceof 进行类型检查和强制类型转换时，应该确保类型转换是安全的，
	即要确保对象的实际类型与你尝试转换的类型是相符的。
如果类型不匹配，会在运行时抛出 ClassCastException 异常。

première voie

if (object instanceof MyClass) {
    
    
    MyClass myObject = (MyClass) object;
    // 此时可以使用 myObject 来访问 MyClass 特有的方法和属性
}

Ici, object est l'objet à vérifier et MyClass est le nom de la classe à vérifier. Si l'objet est une instance de la classe MyClass ou de l'une de ses classes dérivées, la condition sera vraie et le bloc de code sera exécuté. `

Code 1 : juger s'il s'agit d'une certaine classe
class ParentClass {
    
    
    // Contents of the parent class
}

class ChildClass1 extends ParentClass {
    
    
    // Contents of the first child class
}

class ChildClass2 extends ParentClass {
    
    
    // Contents of the second child class
}

public class Main {
    
    
    public static void main(String[] args) {
    
    
        ParentClass obj = new ParentClass(); // This can be an instance of any class
        
        if (obj instanceof ChildClass1) {
    
    
            System.out.println("obj is an instance of ChildClass1");
        } else if (obj instanceof ChildClass2) {
    
    
            System.out.println("obj is an instance of ChildClass2");
        } else {
    
    
            System.out.println("obj is not an instance of ChildClass1 or ChildClass2");
        }
    }
}

Dans cet exemple, nous créons d’abord une instance de ParentClass, puis utilisons l’opérateur instanceof pour vérifier s’il s’agit d’une instance de ChildClass1 ou ChildClass2. Sinon, affichez les informations d'invite correspondantes.

Code 2 : Transfert forcé après appariement
class Animal {
    
    
    public void makeSound() {
    
    
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    
    
    public void makeSound() {
    
    
        System.out.println("Dog barks");
    }
    
    public void fetch() {
    
    
        System.out.println("Dog fetches the ball");
    }
}

public class Main {
    
    
    public static void main(String[] args) {
    
    
        Animal myAnimal = new Dog();

        if (myAnimal instanceof Dog) {
    
    
            Dog myDog = (Dog) myAnimal;
            myDog.fetch(); // 可以调用 Dog 特有的方法
        }

        myAnimal.makeSound(); // 输出：Dog barks
    }
}

Fang 12 : Vérification de type et conversion de type simultanées en jugement conditionnel

if (object instanceof MyClass myObject) {
    
    
    
    // 此时可以使用 myObject 来访问 MyClass 特有的方法和属性
}

Exemple de code :

class MyClass {
    
    
    public void myMethod() {
    
    
        System.out.println("MyClass method");
    }
}

public class Main {
    
    
    public static void main(String[] args) {
    
    
        Object object = new MyClass();

        if (object instanceof MyClass myObject) {
    
    
            myObject.myMethod(); // 可以直接使用 myObject 调用 MyClass 的方法
        }
    }
}

Méthodes de vérification de l'égalité des objets

Cas 1 : La sous-classe a sa propre notion d'égalité, détectée à l'aide de getClass :

Dans ce cas, la sous-classe peut avoir une définition spécifique de l’égalité qui diffère de celle de sa superclasse. Par conséquent, vous devez utiliser getClassdes méthodes pour détecter le type de classe de l’objet et comparer en conséquence.

class Shape {
    
    
    // 父类 Shape
}

class Circle extends Shape {
    
    
    private double radius; // 定义一个私有的double类型的成员变量radius，表示圆的半径

    public Circle(double radius) {
    
    
        this.radius = radius; // 构造函数，接受一个double类型的参数radius，并将其赋值给类的成员变量radius
    }

    @Override
    public boolean equals(Object obj) {
    
    
        // 重写equals方法
        if (obj == this) {
    
    
            return true; // 如果obj等于当前对象，返回true
        }
        if (obj == null || obj.getClass() != this.getClass()) {
    
    
            return false; // 如果obj为null或者其类类型与当前对象的类类型不同，返回false
        }
        Circle other = (Circle) obj; // 将obj强制转换为Circle类型
        return this.radius == other.radius; // 比较其radius成员变量与当前对象的radius成员变量是否相等，如果相等，则返回true，否则返回false
    }
}

class Square extends Shape {
    
    
    public double side; // 定义一个公有的double类型的成员变量side，表示正方形的边长

    public Square(double side) {
    
    
        this.side = side; // 构造函数，接受一个double类型的参数side，并将其赋值给类的成员变量side
    }

    @Override
    public boolean equals(Object obj) {
    
    
        // 重写equals方法
        if (obj == this) {
    
    
            return true; // 如果obj等于当前对象，返回true
        }
        if (obj == null || obj.getClass() != this.getClass()) {
    
    
            return false; // 如果obj为null或者其类类型与当前对象的类类型不同，返回false
        }
        Square other = (Square) obj; // 将obj强制转换为Square类型
        return this.side == other.side; // 比较其side成员变量与当前对象的side成员变量是否相等，如果相等，则返回true，否则返回false
    }
}

public class Mains {
    
    
    public static void main(String[] args) {
    
    
        Circle circle1 = new Circle(5.0); // 创建一个Circle对象，circle1，半径为5.0
        Circle circle2 = new Circle(5.0); // 创建一个Circle对象，circle2，半径为5.0

        System.out.println(circle1.equals(circle2)); // 调用circle1的equals方法，将circle2作为参数传入，然后将返回的结果打印到控制台
    }
}

analyser

@Override
public boolean equals(Object obj) {
    
    
    if (obj == this) {
    
    
        return true;
    }
    if (obj == null || obj.getClass() != this.getClass()) {
    
    
        return false;
    }
    Circle other = (Circle) obj;
    return this.radius == other.radius;
}

Il s'agit de la méthode equals de la classe Circle, qui accepte un paramètre obj de type Object. Cette méthode vérifie d'abord si obj est égal à l'objet actuel et renvoie true si c'est le cas. Il vérifie ensuite si obj est nul ou si son type de classe est différent du type de classe de l'objet actuel, et renvoie false si c'est le cas. Enfin, il convertit obj en type Circle, compare sa variable membre radius avec la variable membre radius de l'objet actuel, et renvoie true si elles sont égales, ou false sinon.

[ 0 ] ce sens

Dans if (obj == this)cette ligne, cela représente l'objet Circle actuel. Cette déclaration de jugement signifie que si l'objet obj transmis est l'objet actuel (c'est-à-dire que obj et this font référence au même objet), alors true est renvoyé, indiquant qu'ils sont égaux.

Dans return this.radius == other.radius;cette ligne, cela représente également l'objet Circle actuel. Cette instruction return signifie que si le rayon (this.radius) de l'objet Circle actuel est égal au rayon (other.radius) de l'objet Circle entrant (other), alors renvoie true, indiquant que les deux objets Circle sont égaux.

[ 2 ](Obj objet)

Dans la définition de cette méthode égale, Object obj est le paramètre de la méthode. Lorsque vous appelez la méthode equals et transmettez un paramètre, la valeur du paramètre sera affectée à obj.

Par exemple, lorsque vous appelez circle1.equals(circle2), la référence de circle2 sera affectée à obj. Ensuite, dans la méthode égale, vous pouvez utiliser obj pour accéder à l'objet passé.

Résumer:

Dans le cas 1, pour garantir que les objets comparés sont des instances de la même classe, nous utilisons la méthode getClass(). En effet, en Java, le paramètre de la méthode equals() est de type Object, qui peut accepter n'importe quel objet comme paramètre. Par conséquent, nous devons effectuer une vérification de type dans la méthode equals() pour nous assurer que l'objet transmis est une instance de la même classe que l'objet actuel.

Dans le cas 1, nous vérifions d’abord si l’objet transmis est le même objet que l’objet actuel, et si c’est le cas, renvoyons true. Il s’agit d’une étape d’optimisation, puisqu’un objet est toujours égal à lui-même.

Ensuite, nous utilisons la méthode getClass() pour vérifier si le type de classe de l'objet transmis est le même que le type de classe de l'objet actuel. Sinon, cela signifie que l'objet transmis n'est pas une sous-classe ou une superclasse de l'objet actuel, ils ne peuvent donc pas être égaux et nous renvoyons false.

La vérification de type avec la méthode getClass() est une pratique courante dans le cas 1, car elle garantit que les objets comparés sont des instances de la même classe. Cela évite les erreurs de non-concordance de type lors de la comparaison.

Il convient de noter que lors de l'utilisation de la méthode getClass() pour la vérification de type, nous supposons que l'objet transmis n'est pas nul. Ainsi, avant de procéder à la vérification du type, nous vérifions si l'objet transmis est nul et, si c'est le cas, renvoyons false.

Pour résumer, dans le cas 1, la méthode getClass() doit être utilisée pour la vérification de type afin de garantir que les objets comparés sont des instances de la même classe. Cela évite les erreurs de non-concordance de type et garantit l'exactitude de la méthode equals().

Cas 2 : Le concept d'égalité est déterminé par la superclasse, et instanceof est utilisé pour détecter :

Dans ce cas, la superclasse détermine la définition d'égalité des objets, et les objets de différentes sous-classes peuvent également être considérés comme égaux. Vous pouvez utiliser instanceofdes mots-clés pour détecter si un objet est une instance d'une certaine classe.

class Animal {
    
    
    // 父类 Animal
    protected String species;
    
    public Animal(String species) {
    
    
        this.species = species;
    }
    
    @Override
    public boolean equals(Object obj) {
    
    
        if (obj == this) {
    
    
            return true;
        }
        if (obj == null || !(obj instanceof Animal)) {
    
    
            return false;
        }
        Animal other = (Animal) obj;
        return this.species.equals(other.species);
    }
}

class Dog extends Animal {
    
    
    public Dog() {
    
    
        super("Dog");
    }
}

class Cat extends Animal {
    
    
    public Cat() {
    
    
        super("Cat");
    }
}

public class Main {
    
    
    public static void main(String[] args) {
    
    
        Animal dog = new Dog();
        Animal cat = new Cat();
        
        System.out.println(dog.equals(cat));  // false，因为它们的种类不同
    }
}

Ces exemples montrent comment implémenter des comparaisons d'égalité d'objets dans différentes situations, en fonction du type d'objet et de la définition d'égalité.

fausseRaison :

Puisque Dog et Cat sont des sous-classes d’Animal, ils héritent de la méthode equals() de la classe parent Animal. Dans ce cas, dog.equals(cat) renvoie false car leurs propriétés d'espèce ne sont pas égales.

Par conséquent, dans le cas 2, la comparaison de la méthode equals() est effectuée entre les sous-classes, et la question de savoir si les objets sont égaux est jugée en comparant les attributs hérités de la classe parent.
insérer la description de l'image ici

équivaut à

Dans la classe Animal, la méthode equals() est remplacée pour comparer l’égalité des objets. Dans la méthode equals(), vérifiez d’abord si l’objet entrant est le même objet que l’objet actuel, et si c’est le cas, renvoyez true. Ensuite, utilisez instanceof pour vérifier si l'objet transmis est une instance de la classe Animal ou de ses sous-classes. Si ce n'est pas le cas, ou si l'objet transmis est nul, renvoie false. Enfin, convertissez les objets entrants en type Animal et comparez les propriétés de leurs espèces pour voir si elles sont égales.
insérer la description de l'image ici

Java.util.Array : longueur, position de la phase de l'élément --> vrai

equals()Le prototype de la méthode est le suivant :

public static boolean equals(type[] a, type[] b)

Tableaux de types de données primitifs (tels que int[], double[], char[], etc.).
Tableaux de types de données de référence (tels que String[], Object[], tableaux de classes personnalisés, etc.).

java.lang.ObjectLe prototype de la méthode de la classe equalsest le suivant :

public boolean equals(Object obj)

equalsLa méthode est utilisée pour comparer deux objets pour l’égalité. Par défaut, equalsles méthodes Objectsont comparées à l'aide de l'adresse de référence de l'objet dans la classe, c'est-à-dire pour déterminer si deux objets font référence à la même adresse mémoire. Cependant, dans de nombreux cas, nous devons juger s'ils sont égaux en fonction du contenu des objets. Ainsi, dans de nombreuses classes personnalisées, les méthodes doivent être remplacées equalspour modifier le comportement de comparaison par défaut.

Pour remplacer equalsune méthode, les conditions suivantes doivent généralement être remplies :

  1. Réflexivité : pour toute valeur de référence non nulle x, x.equals(x)elle doit être renvoyée true.
  2. Symétrie : pour toute valeur de référence non nulle xet , doit renvoyer ysi et seulement si y.equals(x)renvoie .truex.equals(y)true
  3. Transitivité : pour toute valeur de référence non nulle x, yet z, si x.equals(y)renvoie true, et y.equals(z)renvoie également true, alors x.equals(z)devrait renvoyer true.
  4. Cohérence : pour toute valeur de référence non nulle xet , plusieurs appels doivent toujours renvoyer le même résultat ysi les propriétés des deux objets n'ont pas changé .x.equals(y)
  5. Pour toute valeur de référence non nulle x, x.equals(null)doit être renvoyée false.

En utilisation réelle, en particulier dans les classes personnalisées, equalsles méthodes doivent être implémentées en fonction des propriétés des objets, et pas seulement en comparant les adresses de référence. Cela garantit que deux objets sont jugés égaux selon les conditions d'égalité que vous définissez.

Adaptez-vous à la situation :

Vous devez décider quel cas utiliser en fonction de la situation spécifique pour garantir l'exactitude et le comportement attendu de la méthode equals().

Cas 1 : La sous-classe a sa propre notion d'égalité, détectée à l'aide de getClass() :

选择使用哪种情况取决于你的需求和设计。
如果子类具有自己的相等性概念，并且需要比较特定的属性来确定对象是否相等，那么情况1是更合适的选择。
  • Utile pour les sous-classes avec des notions d'égalité personnalisées qui doivent comparer des propriétés ou des états spécifiques pour déterminer si les objets sont égaux.
  • La sous-classe remplace la méthode equals() de la classe parent et utilise la méthode getClass() pour vérifier si l'objet transmis est une instance de la même classe.
  • L'égalité des objets est testée en comparant des propriétés spécifiques.

Cas 2 : Le concept d'égalité est déterminé par la superclasse, et instanceof est utilisé pour détecter :

如果超类已经定义了对象的相等性概念，并且子类继承了这个概念，那么情况2是更合适的选择。
  • S'applique aux superclasses qui définissent une notion d'égalité pour les objets, et les sous-classes héritent de cette notion d'égalité.
  • La superclasse définit la méthode equals() et utilise instanceof pour vérifier si l'objet transmis est une instance de la superclasse ou de ses sous-classes.
  • L'égalité des objets est testée en comparant les propriétés définies par les superclasses.

Je suppose que tu aimes

Origine blog.csdn.net/m0_74154295/article/details/132122277
conseillé
Classement
du quotidien
Plus
2024-06-01(0)
2024-05-31(0)
2024-05-30(1)
2024-05-29(0)
2024-05-28(1)
2024-05-27(0)
2024-05-26(0)
2024-05-25(1)
2024-05-24(12)
2024-05-23(34)

Code World

© 2018 codetd.com