里氏替换原则
所有引用基类的地方必须能透明的使用子类的对象,
在使用继承的时候,要遵循里氏替换原则,子类尽量是不要对父类的方法进行重写的。能直接明显的调用其方法来进行使用,不会出现模棱两可的现象。
里氏替换原则实际上是直接使得两个类的耦合性增强了,在适当的情况下是可以使用依赖,组合,聚合的方式将其问题解决掉。
常规的操作
package com.yt.liscov.basis;
/**
* @program: designPattern
* @description
* @author: YangTao
* @create: 2024-02-27 21:31
**/
public class LiscovTest {
public static void main(String[] args) {
A a = new A();
System.out.println(a.func1(12 , 23));
System.out.println(a.func1(22 , 1));
B b = new B();
//这里出现模棱两可的方法行为,想要调用a的方法通过子类,但是子类的方法对其又进行了重写我
//的操作。出现了错误的情况!
System.out.println(b.func1(12 , 23));
System.out.println(b.func1(22 , 1));
}
}
class A{
public int func1(int num1 , int num2){
return num1 - num2;
}
}
class B extends A{
public int func1(int num1 , int num2){
return num1 + num2;
}
public int func2(int num1 , int num2){
return func1(num1 , num2) + 1;
}
}
将其问题解决掉,可以使用一个基类,是其两个类都继承这个基类。形成一个新的继承关系。原先的关系可以使用组合,依赖,聚合的方式来处理。
里氏替换之后的原则处理
package com.yt.liscov.improve;
/**
* @program: designPattern
* @description
* @author: YangTao
* @create: 2024-02-27 21:31
**/
public class LiscovTest {
public static void main(String[] args) {
A a = new A();
System.out.println(a.func1(12 , 23));
System.out.println(a.func1(22 , 1));
B b = new B();
//这里出现模棱两可的方法行为,想要调用a的方法通过子类,但是子类的方法对其又进行了重写我
//的操作。出现了错误的情况!
System.out.println(b.func1(12 , 23));
System.out.println(b.func1(22 , 1));
}
}
//直接将原来的继承关系发生新的改变形成直接的新的继承关系
abstract class Basis{
abstract int func1(int num1 , int num2);
}
class A extends Basis{
public int func1(int num1 , int num2){
return num1 - num2;
}
}
class B extends Basis{
private A a = new A();
public int func1(int num1 , int num2){
return num1 + num2;
}
public int func2(int num1 , int num2){
return func1(num1 , num2) + 1;
}
public int func3(int num1 , int num2){
return a.func1(num1 , num2);
}
}