Répertoire d'articles
Préface
L'héritage est une propriété importante de la programmation orientée objet (POO). C'est un mécanisme en Java qui permet à une classe d'hériter des caractéristiques (champs et méthodes) d'une autre classe. Il existe deux mots clés principaux, "extend" et "implements", qui sont utilisés pour l'héritage en Java.
Conseil: ce qui suit est le contenu de cet article, les cas suivants sont pour référence
Une, interface et définition de classe abstraite
Interface (outils)
En Java, le mot clé implements est utilisé pour implémenter des interfaces. Une interface est un type spécial de classe qui implémente une abstraction complète et ne contient que des méthodes abstraites. Pour accéder aux méthodes d'interface, l'interface doit être "implémentée" par une autre classe avec le mot clé implements, et les méthodes doivent être implémentées dans une classe qui hérite des propriétés d'interface. Puisque les interfaces n'ont aucune implémentation de méthodes, une classe peut implémenter n'importe quel nombre d'interfaces à la fois. ,
Exemples:
// Defining an interface
interface One {
public void methodOne();
}
// Defining the second interface
interface Two {
public void methodTwo();
}
// Implementing the two interfaces
class Three implements One, Two {
public void methodOne()
{
// Implementation of the method
}
public void methodTwo()
{
// Implementation of the method
}
}
Exemples d'implémentation multiples:
brightness_4
// Defining the interface One
interface One {
void methodOne();
}
// Defining the interface Two
interface Two {
void methodTwo();
}
// Interface extending both the
// defined interfaces
interface Three extends One, Two {
}
Résumé (étend)
En Java, le mot clé extend est utilisé pour indiquer que la classe en cours de définition est dérivée de la classe de base à l'aide de l'héritage. Donc, fondamentalement, le mot clé extend est utilisé pour étendre les fonctions de la classe parent à la classe enfant. En Java, l'héritage multiple n'est pas autorisé. Par conséquent, une classe ne peut étendre qu'une seule classe pour éviter toute ambiguïté.
exemple:
class One {
public void methodOne()
{
// Some Functionality
}
}
class Two extends One {
public static void main(String args[])
{
Two t = new Two();
// Calls the method one
// of the above class
t.methodOne();
}
}
Exemple: pandas est un outil basé sur NumPy, qui a été créé pour résoudre des tâches d'analyse de données.
2. Interface de contraste et abstraction
| Numéro de série \ classe | Interface (outils) | Résumé (étend) |
|---|---|---|
| 1 | En utilisant le mot-clé "implements", les classes peuvent implémenter des interfaces | En utilisant le mot-clé "extend", une classe peut hériter d'une autre classe ou une interface peut hériter d'autres interfaces |
| 2 | La classe qui implémente l'interface doit implémenter toutes les méthodes de l'interface | L'extension de la sous-classe de la superclasse ne couvre pas nécessairement toutes les méthodes de la superclasse |
| 3 | Une classe peut implémenter n'importe quel nombre d'interfaces à la fois | Une classe ne peut étendre qu'une seule super classe |
| 3 | Une interface ne peut jamais implémenter une autre interface | N'importe quel nombre d'interfaces peut être étendu via des interfaces |
Trois, scénarios d'utilisation
Quatre, expansion
Après Java 8, les interfaces peuvent également être implémentées par des méthodes
À partir de Java 8, l'interface a ajouté la prise en charge de la méthode par défaut. Après Java 9, vous pouvez même définir une méthode par défaut privée. La méthode par défaut fournit un moyen compatible binaire d'étendre l'interface existante. Par exemple, nous connaissons java.util.Collection, qui est l'interface racine du système de collecte. Une série de méthodes par défaut ont été ajoutées à Java 8, principalement pour augmenter les fonctions liées à Lambda et Stream. Pour les classes d'outils telles que Collections que j'ai mentionnées plus tôt dans la colonne, de nombreuses méthodes peuvent être implémentées comme méthodes par défaut dans l'interface de base.
public interface Collection<E> extends Iterable<E> {
/**
* Returns a sequential Stream with this collection as its source
* ...
**/
default Stream<E> stream() {
return StreamSupport.stream(spliterator(), false);
}
}
Pour résumer
1 Il est nécessaire d'avoir une compréhension approfondie des trois caractéristiques de l'orientation objet: l'encapsulation, l'héritage et le polymorphisme.
2 Il est nécessaire de comprendre les principes de conception les plus basiques dans le développement quotidien Les six principes du mode de conception SOLID doivent être maîtrisés (j'ajouterai du contenu pertinent dans le blog plus tard).
Responsabilité unique (responsabilité unique), une classe ou un objet est préférable d'avoir une seule responsabilité, si vous constatez qu'une certaine classe a plusieurs obligations dans la conception du programme, vous pouvez envisager de la scinder.
Le principe du commutateur (ouverture-fermeture, ouverture pour extension, fermeture pour modification), la conception doit être ouverte à l'extension et fermée à la modification. En d'autres termes, la conception du programme doit garantir une évolutivité fluide et essayer d'éviter de modifier les implémentations existantes en raison de l'ajout de fonctions similaires, de sorte que moins de problèmes de régression puissent être produits.
La substitution de Liskov (substitution de Liskov) est l'un des éléments de base de l'orientation objet. Lors de l'abstraction de la relation d'héritage, partout où la classe parent ou de base peut être utilisée, elle peut être remplacée par une sous-classe.
Ségrégation des interfaces. Lorsque nous concevons des classes et des interfaces, si trop de méthodes sont définies dans une interface, ses sous-classes sont susceptibles de faire face à un dilemme, c'est-à-dire que seules certaines méthodes ont un sens pour elle, ce qui détruit Cohésion du programme.
Dans ce cas, le comportement peut être découplé en se divisant en plusieurs interfaces avec une seule fonction. Lors de la maintenance future, si la conception d'une interface change, cela n'affectera pas les sous-classes qui utilisent d'autres interfaces.
Inversion de dépendance, les entités doivent s'appuyer sur l'abstraction plutôt que sur l'implémentation. En d'autres termes, les modules de haut niveau ne devraient pas reposer sur des modules de bas niveau, mais devraient être basés sur l'abstraction. Pratiquer ce principe est une arme magique pour assurer un bon couplage entre les codes produits.