软件复用是用已经存在的软件要素去实现或更新软件系统的过程。
面向复用编程–开发出可复用的软件
基于复用编程–利用已有的可复用软件搭建应用系统
复用的原因:
1.复用可以降低成本、减少开发时间;
2.复用的产品经过充分测试,更加可靠、稳定;
3.标准化,在不同的应用中保持一致
被使用的产品规模越大、数量越多,相应的复用成本越低。
而开发可复用的软件,其开发成本高于一般软件的成本(考虑到适应性),其性能也相对较差(考虑到缺少针对性)
在使用可复用的软件时,常常无法不能直接使用,需要根据自己的场景进行相应的修改、适配。
下面是JDK中的可复用库和API的视图:
一个有较高可复用性的软件应当有如下特点:
1.Brief and Simple–小、简单
2.Protable and Standard Compliance–与标准兼容
3.Adaptable and Flexible–灵活可变
4.Extensibility–可扩展
5.Generic and Parameterization–泛型、参数化
6.Modularity–模块化
7.Localization of volatile design assumptions–变化的局部性
8.Stability under changing requirements–稳定
9.Rich documentation–丰富的文档和帮助
最主要的复用是在代码层面,但是软件构造过程中的任何实体都可能被复用,分为如下几个维度:
1.源代码层面:methods、statements等
2.模块层面:class、interface
3.库层面:API
4.体系结构层面:框架
除此之外,按照源代码是否可见、是否可以修改又分为白盒复用和黑盒复用。
白盒复用源代码可见,可修改,其可定制化程度较高,对其修改增加了软件的复杂度,需要对内部充分了解。
黑盒复用源代码不可见,不能修改,只可以API接口使用,简单、清晰,但是适应性较差
代码层面复用,是最低层次的复用,常见的有copy/paste需要的部分到项目中。但是存在一定的维护问题,出错的风险也较高,需要对被使用的框架足够了解且能得到源代码。
Module-level reuse–class/interface类是代码重用的原子单元,不需要源代码、类文件或jar/zip,只需要包含在类路径中,可以使用javap工具获取类的公共方法头。
文档非常重要(Java API);封装有助于重用;要管理的代码更少;版本控制、向后兼容性仍然存在问题;需要将相关类打包在一起–静态链接
继承是一种复用类的方法,在继承中可能需要重写部分已有的方法。在继承体系中,通常需要先设计好继承体系,由于方法、属性不能在后续取消,因此小心避免冗余。
委托也是一种复用的方法,只是一个对象依赖另一个对象,其功能的某个子集(一个实体向其他实体),明智的委托支持代码重用。
委托又有显示、隐式之分。显式委托,将发送对象传递给接收对象;隐式委托,根据语言的成员查找规则。
委托可以描述为一种低级的共享机制,实体之间的代码和数据。
库是提供可复用功能的类和方法(API)的集合。
开发者构造可运行软件实体,其中涉及到对可复用库的调用。
框架是可定制为应用程序的可重用框架代码,框架调用回客户端代码。
框架作为主程序加以执行,执行过程中调用开发者所写的程序。
一个好的API有如下的特点:
1.易于学习
2.易于使用,甚至无需文档
3.难以滥用
4.易于阅读和维护使用它的代码
5.足够强大以满足要求
6.易于进化
7.适合观众
框架是一组具体类、抽象类及其之间的练习关系,开发者根据框架的规约,填充自己的代码,形成完整系统。
开发者根据框架预留的接口所写程序,填充到框架中。
框架可以黑盒框架和白盒框架。
黑盒框架,通过实现特定接口/委托进行框架扩展,通过为组件定义接口来实现可扩展性,通过定义符合特定接口的组件来重用现有功能,这些组件通过委托与框架集成。
白盒框架,通过继承和动态绑定实现可扩展性,通过将框架基类子类化和重写预定义的hook方法来扩展现有功能,通常使用模板方法模式等设计模式覆盖hook方法。
子类型多态,客户端可用统一的方式处理不同类型的对象。
Animal a = new Animal(); Animal c1 = new Cat(); Cat c2 = new Cat();
在可以使用a的场景,都可以用c1和c2代替而不会有任何问题。
如果对于类型T的对象x,q(x)成立,那么对于类型T的子类型S的对象y,q(y)也成立。–LSP原则
概括起来为如下几点:
1.子类型可以增加方法,但不可以删;
2.子类型需要实现抽象类型中所有未实现的方法;
3.子类型重写的方法必须要有相同或子类型的返回值或者符合co-variant的参数;
4.子类型中重写的方法必须使用同样类型的参数或者符合contra-varaint的参数(目前Java按照重载处理);
5.子类型中重写的方法不能抛出额外的异常。
在规约方面则为如下几点:
1.更强的不变量;
2.更弱的前置条件;
3.更强的后置条件。
具体样例如下:
上述样例重写的方法有相同的前置条件、后置条件。
上述样例start方法有更弱的前置条件,而brake有更强的后置条件。
上述样例中父类Rectangle有setWidth方法,而子类Square未重写此方法,子类可以通过调用父类的方法来改变属性w,但是属性h不会随着调用setWidth改变w而对应的改变,不满足h=w,所以不符合LSP。
总结起来,LSP需要满足以下限制:
1.前置条件不能强化;
2.后置条件不能弱化;
3.不变量要保持;
4.子类型方法参数–逆变;
5.子类型方法的返回值–协变;
6.异常类型–协变。
协变是向更加具体方向变化。
父类型为T,a方法返回值为Object;子类型为S,a方法返回值为String,这就是返回值类型的协变。
同样地,有下述异常类型的协变样例:
逆变是向更抽象的方向变化。
父类型为T,方法c的参数s为String类型;子类型为S,方法c的参数s为Object类型,这就是参数类型的逆变。
但是,目前Java将此种情况视为重载。
Java中数组是协变的,对于T[]数组,可以保存类型T及其子类型的数据。
Number[] numbers = new Number[2];
numbers[0] = new Integer(10);
numbers[1] = new Double(3.14);
Integer[] myInts = {1,2,3,4};
Number[] myNumber = myInts;
myNumber[0] = 3.14;//运行时错误
在运行时,Java知道此数组被实例化为Integer类型的数组,只是通过Number[]引用进行访问。
泛型是类型不变的,例如:ArrayList
ListmyInts = new ArrayList<>(); myInts.add(1); myInts.add(2); List myNums = myInts; //编译错误 myNums.add(3.14);//如果上一行编译通过,这一行就不安全
在虚拟机中没有泛型类型对象,所有对象都属于普通类。泛型信息只存在于编译阶段,在运行时会被“擦除”。
定义泛型时,会自动提供一个对应的原始类型(非泛型类型),原始类型的名字就是去掉类型参数后的泛型类型名。
擦除时类型变量会被擦除,替换为限定类型(用第一个限定类型),如果没有限定类型则替换为Object类型。
另外,运行时类型查询只适用于原始类型:
if(a instanceof Pair)//编译错误 if(a instanceof Pair )//编译错误 Pair stringPair = ...; Pair employeePair = ...; if(StringPair.getClass()==employeePair.getClass()){...}//他们是相等的
可以采用通配符实现两个泛型类的协变。
无限定通配符?List>,方法的实现不依赖于类型参数或者只依赖于Object类中的功能,则无限定通配符是有用的。
无限定通配符,一般用于定义一个引用变量,可以指向多个不同类型的变量,例如:
SpuerClass> sup0 = new SuperClass(); sup0 = new SuperClass (); sup0 = new SuperClass ();
不适用?,用固定类型,则需要使用下面的实现:
SuperClasssup1 = new SuperClass (); SuperClass sup2 = new SuperClass (); SuperClass sup3 = new SuperClass ();
public static void printList(List
上述的printList无法打印任意类型的List,只能打印参数类型为Object类型的List,而通过使用无限通配符,可以打印任意参数类型的List。
下限通配符, super A>,可以使用A及其父类作为参数类型。
上限通配符, extends A>,可以使用A及其子类作为参数类型。
注意List extends Number> list,虽然使用了通配符,但是不意味着同一个list可以存放不同类型的对象,无限定通配符、下限通配符同理。
限定的类型参数允许调用限定类型的方法。
public class NaturalNumber{ private T n; public NaturalNumber(T n) { this.n = n; } public boolean isEven() { return n.intValue() % 2 == 0; }// ... }
同样是List类型,参数类型为Number的是参数类型为?的子类,是参数类型为? extends Object的子类;参数类型为Object的是参数类型为? super String的子类.
PECS部分暂时不做总结。
Delegation and Compostionint compare(T o1,T o2)是比较两个参数顺序的接口,ADT需要比较大小,或者放入Collections或Arrays中排序,可以实现Comparator接口并重写compare()函数,例如下图的实现:
另一种方法是ADT实现Comparable接口,再重写compareTo()方法,但是这不再是委托机制。
委托,一个对象请求另一个对象的功能,是复用的一种常见形式。
显示委托,通过将发送对象传递给接收对象;隐式委托,根据语言的成员查找规则。
很多设计模式把继承和委托结合使用。
如果子类只需要复用父类的小部分方法,可以考虑委托机制实现,不需要继承父类所有方法,避免继承大量无用的方法。
同一个功能,继承版本和委托版本如下:
class RealPrinter {
void print() {
System.out.println("Printing Data");
}
}
class Printer extends RealPrinter {
void print(){
super.print();
}
}
Printer printer = new Printer();
printer.print();
class RealPrinter {
void print() {
System.out.println("The Delegate");
}
}
class Printer {
RealPrinter p = new RealPrinter();
void print() {
p.print();
}
}
Printer printer = new Printer();
printer.print();
CRP,组合优先于继承(组合是委托的一种形式)。委托发生在对象层次,而继承则发生在类的层次。
在具体实现中,使用接口定义系统必须对外展示的不同侧面的行为,接口之间通过extends实现行为扩展,类实现组合接口,避免复杂的继承关系。
下面是一个比较详细的实例:
interface Flyable {//定义抽象行为的接口
public void fly();
}
interface Quackable {//定义抽象行为的接口
public void quack();
}
class FlyWithWings implements Flyable {//接口的具体实现
@Override
public void fly() {
System.out.println("fly with wings");
}
}
class Quack implements Quackable {//接口的具体实现
@Override
public void quack() {
System.out.println("quack like duck");
}
}
interface Ducklike extends Flyable, Quackable {}//接口的组合,定义了行为的组合
public class Duck implements Ducklike {//从组合接口中派生具体类
Flyable flyBehavior;//委托
Quackable quackBehavior;
void setFlyBehavior(Flyable f) {//设置委托对象实例
this.flyBehavior = f;
}
void setQuackBehavior(Quackable q) {
this.quackBehavior = q;
}
@Override
public void fly() {//通过委托实现具体行为
this.flyBehavior.fly();
}
@Override
public void quack() {
this.quackBehavior.quack();
}
}
client对接口进行编程:
Flyable f = new FlyWithWings(); Quackable q = new Quack(); Duck d = new Duck(); d.setFlyBehavior(f); d.setQuackBehavior(q); d.fly(); d.quack();
Dependency,A使用B是临时性的委托,通过方法的参数或者在方法的局部使用发生联系,例如:
class Duck {
//no field to keep Flyable object
void fly(Flyable f) {
f.fly();
}
}
Flyable f = new FlyWithWings();
Quackable q = new Quack();
Duck d = new Duck();
d.fly(f);
d.quack(q);
Association,A有B是永久性的委托,例如:
class Duck {
Flyable f = new CannotFly();
void Duck(Flyable f) {
this.f = f;
}
void Duck() {
f = new FlyWithWings();
}
void fly() { f.fly();
}
}
Flyable f = new FlyWithWings();
Duck d = new Duck(f);
Duck d2 = new Duck();
d.fly();
Compostion/aggregation,A拥有B,是Association的两种具体形态。
Compostion是更强的assocation,但是难以变化,例如:
class Duck{
Fylable f = new FlyWithWings();
void fly(){
f.fly();
}
}
Duck d = new Duck();
d.fly();
Aggregation是更弱的association,可以动态变化,例如:
class Duck{
Flyable f;
void Duck(Flyable f){
this.f = f;
}
void setFlyBehavior(f){
this.f = f;
}
void fly(){
f.fly();
}
}
Flyable f = new FlyWithWings();
Duck d = new Duck(f);
d.fly();
d.setFlyBehavior(new CannotFly());
d.fly();
上述几种不同种类的委托都是支持一对多的委托。
class Professor {
List ls; //永久保存delegation关系
void enroll(Student s) {
this.ls.add(s); //建立delegation关系
}
void evaluate() {
double score = 0;
for(Student s : ls)
score += s.evaluate(this); //逐个delegate
}
}
Designing system-level reusable API libraries and Frameworks
API是程序员最重要的资产和荣耀,可以吸引外部用户,提高声誉。
设计API存在一定难度,要有足够良好的设计,一旦发布就无法自由改变了。
白盒框架使用的是子类或子类型,是继承,允许扩展每个非私有方法,需要了解超类的实现,一次只能有一个分机,一起编译,通常所谓的开发人员框架;
一种使用白盒框架的方法:
另外一种:
黑盒框架使用的是组成要素,是委托/组合,允许扩展接口中公开的功能,只需要了解接口,多个插件,通常提供更多的模块化,可以单独部署(.jar、.dll、…),通常是所谓的最终用户框架、平台。
一种使用黑盒框架的方法:
另外一种使用方法:



