设计模式-里氏代换原则

含义

  任何基类可以出现的地方,子类一定可以出现。子类可以扩展父类的功能,但不能改变父类原有的功能。换句话说,子类继承父类时,除了添加新的方法完成新增的功能外,尽量不要重写父类的方法。

当然还有人给出另一种解释:“里氏替换原则”的意思并不是 “子类不能重写父类的方法”,而是 “子类重写父类方法时,可以改变方法的具体行为,但不应该改变方法的用途”。比如一个父类有一个排序的功能,子类可以重写来改变排序的算法,但不应该改变排序这个功能,这样父类才可以被子类替换。

案例一

  父类中存在一个排序方法,现在修改需求在排序完成后转为字符串返回,通过子类继承父类扩展方法来实现。

基类或父类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class SortBase {
public int[] sort(int[] array){

int n = array.length ,temp;

// 冒泡排序
for(int i=0;i<n-1;i++)
for (int j = 0; j < n - 1 - i; j++)
{
if (array[j] > array[j + 1])
{
temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}

return array;
}
}

子类继承父类,添加新的方法完成需求,在新方法中使用父类函数完成原有需求

1
2
3
4
5
6
7
8
9
10
public class SortChild extends SortBase{

public String sortToString(int[] array){
// 调用父类的排序方法
int[] sort = sort(array);
String s = Arrays.toString(sort);

return s;
}
}

测试类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class TestDemo {
public static void main(String[] args) {
int a[] = { 1,2,4,5,6,7,3,9};

// 调用父类
SortBase sortBase = new SortBase();
int[] sort = sortBase.sort(a);
for (int item:a)
System.out.print(item+" ");

System.out.println();

// 调用子类方法完成需求添加
SortChild sortChild = new SortChild();
String s = sortChild.sortToString(a);
System.out.println(s);

}
}

1620282659172

  如上,该案例是通过添加新的方法来完成需求

案例二

  方法功能不变,子类重写父类的方法,但不修改父类的功能,只是在代码上进行修改或优化

基类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class SortBase {
public int[] sort(int[] array){

int n = array.length ,temp;

// 冒泡排序
for(int i=0;i<n-1;i++)
for (int j = 0; j < n - 1 - i; j++)
{
if (array[j] > array[j + 1])
{
temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}

return array;
}
}

子类,重写父类方法,将排序算法修改为插入排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public class SortChild extends SortBase{

public String sortToString(int[] array){
// 调用父类的排序方法
int[] sort = sort(array);
String s = Arrays.toString(sort);

return s;
}

public int[] sort(int[] array){
// 使用插入排序
int n = array.length ,j,temp;
for (int i = 1; i < n; i++)
{
temp = array[i];
j = i;
while (j > 0 && array[j - 1] > temp)
{
array[j] = array[j - 1];
j--;
}
array[j] = temp;
}
return array;
}
}

测试类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class TestDemo {
public static void main(String[] args) {
int a[] = { 1,2,4,5,6,7,3,9};

// 调用父类
SortBase sortBase = new SortBase();
int[] sort = sortBase.sort(a);
for (int item:a)
System.out.print(item+" ");

System.out.println();

// 调用子类方法完成需求添加
SortChild sortChild = new SortChild();
String s = sortChild.sortToString(a);
System.out.println(s);

// 子类重写父类的方法,使用插入排序
int[] ints = sortChild.sort(a);
for (int item:ints)
System.out.print(item+" ");


}
}

1620282862046


本博客所有文章除特别声明外,均采用 CC BY-SA 4.0 协议 ,转载请注明出处!