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();

      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当子类的方法实现父类的抽象方法时，方法的后置条件（即方法的返回值）要比父类更加严格。

 

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

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