java框架设计_替换

替换原则

.定义一: 如果对每一个类型为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();
  
4000
    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当子类的方法实现父类的抽象方法时，方法的后置条件（即方法的返回值）要比父类更加严格。

 

 看上去很不可思议，因为我们会发现自己变成中常常会违反替换原则，程序照样运行的好好的。

所以会产生这样的疑问，如果不遵循替换原则会怎么样？ 可以清楚地告诉你：你的代码错误率会大大增加