Quel est le principe de substitution Liskov des modèles de conception Java ?

Principe de substitution de Liskov, appelé LSP

Définition :

Les fonctions qui utilisent des pointeurs ou des références à des classes de base doivent pouvoir utiliser des objets de classes dérivées sans le savoir.

Toutes les références aux classes de base doivent pouvoir utiliser leurs objets de sous-classe de manière transparente.

En d'autres termes, tant que la classe parent apparaît, la sous-classe peut apparaître, et son remplacement par une sous-classe ne provoquera aucune erreur ni exception. Mais à l’inverse, là où des sous-classes apparaissent, des problèmes peuvent survenir si elles sont remplacées par des classes parentes.

Ce principe est de définir une spécification pour un bon héritage. En termes simples, il a 4 niveaux de signification :

1 La sous-classe doit implémenter pleinement les méthodes de la classe parent

Définir une classe abstraite

public abstract class ViewPoint {      //去丽江旅游      public abstract void where();  }

La. suivant deux classes Il s'agit d'implémenter cette classe abstraite

public class Lijiang extends ViewPoint {         @Override     public void where() {          System.out.println("欢迎来到丽江...");      }     }   public class Zhangjiajie extends ViewPoint {         @Override     public void where() {          System.out.println("欢迎来到张家界...");      }     }

Le personnage est Tutu et d'y définir le type de classe pour transmettre les paramètres. À l'heure actuelle, les attractions touristiques que Tutu veut visiter sont encore des scénarios abstraits

public class Tutu {      //定义要旅游的景点      private ViewPoint viewpoint;      //涂涂要去的景点      public void setViewPoint(ViewPoint viewpoint)      {          this.viewpoint = viewpoint;      }             public void travelTo()      {          System.out.println("涂涂要去旅游了");          viewpoint.where();      }  }

. Définissez les attractions spécifiques auxquelles vous souhaitez aller

public class Sence {      public static void main(String args[])      {          Tutu tutu = new Tutu();          //设置要去的旅游景点          tutu.setViewPoint(new Lijiang());          tutu.travelTo();      }  }

Le résultat de l'opération :

Tutu va voyager
Bienvenue à Lijiang...

Deuxièmement, les sous-classes peuvent avoir leurs propres caractéristiques

C'est-à-dire que dans la sous-classe de la classe Sur la classe, vous pouvez définir d'autres méthodes ou attributs

3. Lors du remplacement ou de l'implémentation des méthodes de la classe parent, les paramètres d'entrée peuvent être amplifiés

Là où la classe parent peut exister, la sous-classe peut exister et cela n’affectera pas les résultats en cours. Il y a des changements. L’inverse n’est pas vrai.

Classe Parent, le paramètre dans say() est de type HashMap, qui est un sous-type de type Map. (Parce que la portée de la sous-classe doit être plus grande que celle de la classe parent)

import java.util.Collection;  import java.util.HashMap;     public class Father {      public Collection say(HashMap map)      {          System.out.println("父类被执行...");          return map.values();      }  }

Pour la sous-classe, les paramètres dans say() deviennent le type Map. La plage Map est plus grande que le type HashMap, qui est conforme au LSP. principe. Notez que le say ici n'écrase pas le say de la classe parent car les types de paramètres sont différents. Mais surcharge.

import java.util.Collection;  import java.util.Map;     /*   * 子类继承了父类的所有属性   */ public class Son extends Father {      //方法输入参数类型      public Collection say(Map map)      {          System.out.println("子类被执行...");          return map.values();      }  }

Classe Scene

import java.util.HashMap;     public class Home {      public static void main(String args[])      {          invoke();      }             public static void invoke()      {          //父类存在的地方，子类就应该能够存在          //Father f = new Father();          Son s = new Son();          HashMap map = new HashMap();          //f.say(map);          s.say(map);      }  }

Que la méthode say soit appelée avec la classe parent ou la sous-classe, le résultat est que la classe parent est exécutée...

Cependant, si le paramètre say dans Father ci-dessus est modifié en Map, Changez le paramètre say dans la sous-classe Son en HashMap, et le résultat devient

f.say(map) résultat : la classe parent est exécutée...

s.say(map) résultat : la sous-classe est exécutée ..

Cela provoquera une confusion logique. Par conséquent, les conditions préalables des méthodes de la sous-classe doivent être identiques ou plus larges que les conditions préalables remplacées dans la classe parent.

4. Lors du remplacement ou de l'implémentation de la méthode de la classe parent, le résultat de sortie peut être réduit

En fait, c'est similaire à ce qui précède, c'est-à-dire que la sous-classe peut apparaître là où la classe parent peut apparaître, et le remplacer par une sous-classe ne produira pas d'erreurs ou d'exceptions, l'utilisateur n'a pas besoin de savoir s'il s'agit d'une classe parent ou d'une sous-classe. Mais l’inverse n’est pas vrai partout où des sous-classes apparaissent, la classe parent peut ne pas s’adapter. (Après tout, la portée de la sous-classe doit >= la portée de la classe parent)

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!