替换原则
.定义一: 如果对每一个类型为A1对象b1,都有类型为A2的对象b2,使得以A1定义的所有程序P在所有的对象b1都替换成b2时,程序P的行为没有发生变化.那么类型A2是A1的派生类型.
定义二: 所有的引用基类的地方必须能透明地使用子类的对象
问题由来: 有一功能P1,由类A完成.现在需要将功能P1进行拓展,拓展后的功能为P,其中P是由原来功能P1与新功能P2组成.新功能P又类A的子类B来完成.则派生类B在完成新功能p2的同时,有可能会导致原有功能p1发生故障。
解决方法:当使用继承时,遵循替换原则。当类B继承类A时,除添加新的方法完成新增功能p2外,尽量不要重写父类的方法,也尽量不要重载父类A的方法。
继承包含这样一层含义:父类中凡是已经实现好的方法(相对于抽象方法而言),实际上是在特定一系列的规范和契约,虽然它不强制要求所有子类必须遵守这些契约,但是如果子类对这些非抽象方法任意修改,就会对整个继承体系造成破坏。而替换原则就是表达了这一层的含义。
继承作为面向对象的三大特征(继承,封装,多态)一。在给程序设计带来巨大便利的同时,也带来了弊端。比如继承会给程序带来入侵性,程序的可移植性降低,增加了对象间的耦合性,如果一个类被其他类所继承,则当这个类需要修改时,必须考虑到所有的子类,并且父类修改后,所有涉及带子类的功能都有可能会产生故障。
举例说明继承的风险。我们一个简单的功能,由类A来负责。
package test1;
public classExchange {
publicstaticvoidmain(String[] args) {
Aa=newA();
System.out.println("500-1="+a.func(500,1));
System.out.println("500-2="+a.func(500,2));
}
}
class A{
public int func(int a,int b)
{
return a-b;
}
}
运行结果
500-1=499
500-2=498
后来,我们想增加一个新的功能,完成两个数的相加,然后再与100求和,由B来负责。由B来完成这个功能。
由于A完成了第一个功能,所以类B继承A后,只需要再完成第二个功能即可。
代码如下:
package test1;
public classExchange {
publicstaticvoidmain(String[] args) {
Bb=newB();
System.out.println("200-100="+b.func1(200,100));
System.out.println("100-50="+b.func1(100,50));
System.out.println("100+200+100="+b.func2(100,200));
}
}
class A{
public int func1(int a,int b)
{
return a-b;
}
}
class B extendsA{
public int func1(int a,int b)
{
return a+b;
}
public int func2(int a,int b)
{
return func1(a,b)+100;
}
}
代码运行结果
200-100=300
100-50=150
100+200+100=400
我们发现原本运行正常的相减的功能发生了错误,原因就是类B再给方法起名的同时无意中重写了父类的方法,造成所有运行相减的功能的代码全部调用了类B重写后的方法,造成原本运行正常的功能出现了错误。
本例中,引用了基类A完成的功能换成了子类B之后,发生了冲突。再实际程序过程中,我们常常重写父类的方法来完成功能,这样写起来虽然说简单,但是整个继承体系的可复用性比较差了,特别是运用多态比较频繁时,程序出错率就比较大了。如果非要重写父类的方法,比较通用的做法是,原本的父类和子类都继承一个更加通俗的基类,原来的子类和父类继承关系去掉。采用依赖,聚合,组合等关系代替。
修改之后代码如下:
package test1;
public classExchange {
public static void main(String[] args) {
Bb = newB();
Aa = newA();
System.out.println("200-100="+ a.func3(200, 100));
System.out.println("100-50="+ a.func3(100, 50));
System.out.println("100+200+100="+ b.func3(100, 200));
}
}
abstract classC {
int a, b;
abstract int func3(int a, int b);
}
class A extendsC {
public int func3(int a, int b) {
return a - b;
}
}
class B extendsC {
public int func3(int a, int b) {
return a + b + 100;
}
}
运行结果
200-100=100
100-50=50
100+200+100=400
替换原则通俗的来讲:子类可以扩展父类的功能,但不能改变父类的原有的功能。
它包含4层含义:1子类可以实现父类的抽象方法,但是不能覆盖父类的非抽象方法。
2子类也可以增加自己特有的方法 3当子类重载父类的方法时,方法前置条件(方法的形参)要比父类的方法的输入参数更加宽松。
4当子类的方法实现父类的抽象方法时,方法的后置条件(即方法的返回值)要比父类更加严格。
看上去很不可思议,因为我们会发现自己变成中常常会违反替换原则,程序照样运行的好好的。
所以会产生这样的疑问,如果不遵循替换原则会怎么样? 可以清楚地告诉你:你的代码错误率会大大增加