Différence entre l'héritage et l'interface dans Java

L'héritage et l'interface dans Java sont deux méthodes d'organisation de code différentes, qui sont utilisées pour créer des hiérarchies entre les classes et implémentation de réutilisation du code. L'héritage crée des sous-classes en copiant les propriétés et les méthodes de la classe parent, tandis que l'interface définit un ensemble de signatures de méthode, qui sont implémentées spécifiquement par la classe d'implémentation. Cet article expliquera les principales différences entre les deux et les illustra avec des exemples de code Java.

Exemple de code

Le code suivant démontre l'application de l'interface et de l'héritage:

C.add(5, 10);
C.subtract(35, 15);
C.multiply(6, 9);
C.divide(45, 6);

Résultat de sortie:

<code>The result is here. Have A Look : 15.0
The result is here. Have A Look : 20.0
The result is here. Have A Look : 54.0
The result is here. Have A Look : 7.5</code>

Différences entre l'héritage et l'interface

特性	继承	接口
定义	基类将行为传递给子类。	接口定义了所有声明方法的关系。
代码复用	通过重写方法复用超类代码。	通过多态性提高代码可重用性。
多继承支持	单继承（一个类只能继承一个父类），但可以有多个子类。	支持多继承，无需指定实现细节。

L'héritage

permet à une classe de hériter des fonctionnalités de la classe parent et de la classe des ancêtres. Et l'interface définit le contrat entre l'abstraction et l'ensemble de méthode.

Méthodes et algorithmes

Cet article utilise un exemple de code pour démontrer comment utiliser les collections et les itérateurs pour traiter les données et implémenter les fonctions de calculatrice via les interfaces et l'héritage. Les étapes principales de l'algorithme sont les suivantes:

1. Déclarer le flux d'entrée et de sortie.
2. Importez les classes et fonctions nécessaires.
3. Définir les cours publics.
4. Définissez les méthodes (ajouter, soustraire, multiplier, diviser, imprimer les résultats).
5. Créez un objet de calculatrice et appelez une méthode.
6. Imprimez le résultat.

Exemple de grammaire

Le code suivant montre l'utilisation de Treeset, IdentityHashMap et Hashtable, ainsi que l'application des itérateurs lors de la traversée de la collection, pour illustrer le fonctionnement de l'héritage et de l'interface.

TreeSet STTREE = new TreeSet();
STTREE.add(4);
STTREE.add(5);
STTREE.add(6);
STTREE.add(8);
STTREE.add(4);

IdentityHashMap ihmap = new IdentityHashMap();
ihmap.put(10, "ARB");
ihmap.put(20, "RDD");
ihmap.put(30, "ARBRDD");
ihmap.put(40, "KOLDHKA");
ihmap.put(50, "You");

System.out.println("IdentityHashMap size : " + ihmap.size());
System.out.println("Initial identity hash map :  " + ihmap);

Hashtable table = new Hashtable();
table.put(1, "X");
table.put(2, "Y");
table.put(3, "Z");
table.put(4, "A");

for (Map.Entry m : table.entrySet()) {
    Iterator<Map.Entry> itr = ihmap.entrySet().iterator();
    while (itr.hasNext()) {
        IdentityHashMap.Entry entry = itr.next();
        TreeMap MAPTREE = new TreeMap();
        MAPTREE.put(2, 5);
        MAPTREE.put(3, 6);
        MAPTREE.put(4, 6);
        MAPTREE.put(2, 3);
    }
}

Problème de diamant (problème de diamant)

Le problème du diamant est un problème possible en héritage multiple. L'héritage multiple des interfaces évite la limitation de l'héritage unique et améliore la flexibilité et l'évolutivité du code.

Exemple de code (en utilisant la méthode Diamond)

Le code suivant démontre l'implémentation de la calculatrice à l'aide d'interfaces et de classes d'implémentation:

import java.util.*;

interface ARBRDD {
    public void add(double x, double y);
    public void subtract(double x, double y);
}

interface Mul_Div {
    public void multiply(double x, double y);
    public void divide(double x, double y);
}

interface Calculator extends ARBRDD, Mul_Div {
    public void printResult(double result);
}

public class MyCalculator implements Calculator {
    // ... 方法实现 ...
}

Conclusion

Cet article explique clairement les différences entre l'héritage et les interfaces en Java via un exemple de code et de tableaux, et montre comment les utiliser pour construire des programmes flexibles et extensibles à travers des cas pratiques. Il est essentiel de comprendre la différence entre l'héritage et l'interface pour écrire du code Java de haute qualité.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!