哈工大软件构造课程知识点总结（五）

最新推荐文章于 2024-06-14 11:19:23 发布

[■■■]

最新推荐文章于 2024-06-14 11:19:23 发布

阅读量273

点赞数

分类专栏：哈工大软件构造课程文章标签：设计模式 java 编程语言

本文链接：https://blog.csdn.net/qq_52603806/article/details/118435935

版权

哈工大软件构造课程专栏收录该内容

8 篇文章 4 订阅

订阅专栏

系列文章目录

哈工大软件构造课程知识点总结（一）
哈工大软件构造课程知识点总结（二）
哈工大软件构造课程知识点总结（三）
哈工大软件构造课程知识点总结（四）
哈工大软件构造课程知识点总结（五）
哈工大软件构造课程知识点总结（六）

简介

此文章是2021春哈工大软件构造课程Chapter 9 ~ Chapter 10的知识点总结。

Chapter 9:Construction for Reuse

什么是复用

定义：使用现有软件组件实现或更新软件的过程。
面向复用编程开发出可复用的软件，基于复用编程利用已有的可复用软件搭建应用系统。

复用的层次：

源代码级别的复用：白盒/黑盒复用
模块级别的复用：类/抽象类/接口
库级别的复用：API/包
系统级别的复用：框架（一组具体类、抽象类、及其之间的连接关系）

白盒复用：源代码可见，可修改和扩展（复制已有代码到正在开发的系统，进行修改）

优点：可定制化程度高
缺点：对其修改增加了软件的复杂度，且需要对其内部的充分了解

黑盒复用：源代码不可见，不能修改（只能通过API接口来使用，无法修改代码）

优点：简单清晰
缺点：适应性略差

复用的优点：

降低成本和开发时间
经过充分的测试，可靠、稳定
标准化，在不同应用中保持一致

复用的缺点：

开发成本高于一般软件——要求较高的适应性
性能略差——缺少足够的针对性

复用的机会和场合越多、代价越小则可复用性越好。

Liskov替换原则(LSP)

子类型多态：客户端可用统一的方式处理不同类型的对象。

Liskov替换原则内容

编译器静态检查的原则：
- 子类可以增加方法，但不可删
- 子类需要实现父类中的所有未实现方法
- 子类中重写的方法其返回值必须与父类相同或是父类返回值的子类型（协变）
- 子类中重写的方法其参数必须与父类相同
- 子类中重写的方法不能抛出额外的异常（协变）
对于特定方法（编译器不检查的原则）：
- 更强的不变量（原始的不变量不要改变，可以对新增加的属性加入不变量）
- 更弱的前置条件
- 更强的后置条件

协变示例：

逆变示例：

泛型中的LSP

类型擦除：将泛型中的类型变量使用它们的边界（若有边界）或Object（若无边界）替换，从而使生成的字节码只包含普通的类、接口和方法。

注意：虽然Integer是Number的子类，但Box<Integer>不是Box<Number>的子类！

带通配符泛型的父子关系示例：

委托(Delegation)和组合(Composition)

委托

委托：一个对象请求另一个对象的功能，是复用的一种常见形式。
一个简单的委托示例：

public class Edge {
    Vertex s, t;
    double weight;
    ...
}

public class EdgeComparator implements Comparator<Edge>{
    @Override public int compare(Edge o1, Edge o2) {
        if(.. > ..) return 1;
        else if (.. < ..) return -1;
        else return 0;
    }
}

public void sort(List<Edge> edges) {
    Comparator comp = new EdgeComparator();
    Collections.sort(edges, comp); //把比较的功能委托给一个类
}

如果子类只需要复用父类中的一小部分方法，可以不需要使用继承，而是通过委派机制来调用所需的部分方法，从而避免大量无用的方法。

组合及CRP原则

利用委托的机制，将功能的具体实现与调用分离，在实现中又通过接口的继承树实现功能的不同实现方法，而在调用类中只需要创建具体的子类型然后调用即可。组合就是多个不同方面的委托的结合。如下图：

委托的类型：

依赖(Dependency)：临时的委托
关联(Association)：永久性的委托
组合(Composition)：比关联更强，但难以变化
聚合(Aggregation)：更弱的关联，可动态变化

这几种类型均支持一对多的委托。

具体示例：

/* Dependency 依赖 */
class Duck {
	//没有保存Flyable对象的属性
	void fly(Flyable f) {
		f.fly();
	}
}

/* Association 关联 */
class Duck {
	Flyable f = new CannotFly();
	void Duck(Flyable f) { 
		this.f = f; // 构建对象时确定
	}
	void Duck() {
		f = new FlyWithWings();
	}
	void fly() { f.fly(); }
}

/* Composition 组合 */
class Duck {
	Flyable f = new FlyWithWings(); // 直接在这里确定
	void fly() {
		f.fly();
	}
}

/* Aggregation 聚合 */
class Duck {
	Flyable f;
	void Duck(Flyable f) { 
		this.f = f; 
	}
	void setFlyBehavior(f) {
		this.f = f; // 对象创建后可以修改
	}
	void fly() { f.fly();}
}