Le principe de remplacement de Rich, OCP, en tant que principe de haut niveau de l'OO, préconise l'utilisation de "l'abstraction" et du "polymorphisme" pour changer la structure statique de la conception en une structure dynamique pour maintenir l'enceinte de la conception. "Résumé" est une fonction fournie par la langue. Le «polymorphisme» est mis en œuvre par sémantique héréditaire.
Le principe de remplacement de Richter contient les 4 significations suivantes:
Nous pouvons maintenant expliquer les quatre significations ci-dessus.
Les sous-classes peuvent implémenter des méthodes abstraites de classe parent, mais ne peuvent pas remplacer les méthodes non abstraites de la classe parent.
Lorsque nous concevons des systèmes, nous concevons souvent des interfaces ou des classes abstraites, puis les sous-classes mettent en œuvre des méthodes abstraites. Le principe de remplacement de Richter est en fait utilisé ici. Il est facile de comprendre que les sous-classes peuvent implémenter la méthode abstraite de la classe parent. En fait, les sous-classes doivent implémenter pleinement la méthode abstraite de la classe parent, même s'ils rédigent une méthode vide, sinon ils compileront et rapporteront une erreur.
Le point clé du principe de substitution de Richter est qu'il ne peut pas couvrir les méthodes non abstraites de la classe parent. Toute méthode bien implémentée dans la classe Parent définit en fait une série de spécifications et de contrats. Bien qu'il ne force pas toutes les sous-classes à se conformer à ces spécifications, si la sous-classe modifie arbitrairement ces méthodes non abstraites, cela endommagera l'ensemble du système d'hérédité. Le principe du remplacement de Lizur exprime ce sens.
Dans l'idée de conception orientée objet, hériter de cette fonctionnalité apporte une grande commodité à la conception du système, mais il y a aussi des risques qui en découlent. Les exemples suivants sont utilisés pour illustrer le risque d'hérédité. Nous devons compléter la fonction de soustraire deux nombres, et la classe A en est responsable.
classe A {public int func1 (int a, int b) {return ab; }} public class Client {public static void main (String [] args) {a a = new a (); System.out.println ("100-50 =" + a.func1 (100, 50)); System.out.println ("100-80 =" + a.func1 (100, 80)); }} Résultats en cours:
100-50 = 50100-80 = 20
Plus tard, nous devons ajouter une nouvelle fonction: terminer l'ajout de deux nombres, puis le résumer avec 100, et la classe B est responsable. Autrement dit, la classe B doit remplir deux fonctions:
Les deux nombres soustraient.
Ajoutez deux nombres, puis ajoutez 100.
Étant donné que la classe A a implémenté la première fonction, après la classe B hérite de la classe A, il vous suffit de remplir la deuxième fonction. Le code est le suivant:
La classe B étend un {public int func1 (int a, int b) {return a + b; } public int func2 (int a, int b) {return func1 (a, b) +100; }} public class Client {public static void main (String [] args) {b b = new b (); System.out.println ("100-50 =" + b.func1 (100, 50)); System.out.println ("100-80 =" + b.func1 (100, 80)); System.out.println ("100 + 20 + 100 =" + b.func2 (100, 20)); }} Une fois la classe B terminée, le résultat de l'exécution:
100-50 = 150100-80 = 180100 + 20 + 100 = 220
Nous avons constaté que la fonction de soustraction qui s'exécutait à l'origine avait normalement une erreur. La raison en est que lorsque la classe B a nommé la méthode, il réécrit accidentellement la méthode de la classe parent, provoquant tous les codes qui exécutent les fonctions de soustraction pour appeler la méthode de réécriture de la classe B, provoquant des erreurs dans la fonction normale d'origine. Dans cet exemple, après avoir fait référence à la fonction remplie par la classe A de base et en passant à la sous-classe B, une exception s'est produite. Dans la programmation réelle, nous remplissons souvent de nouvelles fonctions en réécrivant la méthode de la classe parent. Bien qu'il soit simple à écrire, la réutilisabilité de l'ensemble du système d'héritage sera relativement médiocre, en particulier lorsque le polymorphisme est utilisé plus fréquemment, la probabilité d'erreurs de fonctionnement du programme est très élevée. Si vous devez réécrire la méthode de la classe parent, l'approche la plus courante est: la classe parentale originale et la classe infantile héritent d'une classe de base plus populaire, supprimez la relation d'origine d'origine et utilisez à la place la dépendance, l'agrégation, la combinaison et d'autres relations.