软件工程-面向对象设计与法则

主要内容

优先使用(对象)组合,而非(类)继承
针对接口编程,而非(接口的)实现
类的封闭性原则
开放-封闭法则(OCP)
Liskov替换法则(LSP)

优先使用(对象)组合,而非(类)继承

组合定义:
	(对象)组合是一种通过创建一个组合了其它对象的对象,从而获得新功能的复用方法
	将功能委托给所组合的一个对象,从而获得新功能
	有些时候也称之为"聚合"或"包容"
组合两种实现:根据引用和根据值
组合的优点和缺点:
	优点:
		容器类仅能通过被包含对象的接口来对其进行访问
		"黑盒"复用,因为被包含对象的内部细节对外是不可见
		封装性好
		实现上的相互依赖性比较小(译者注:被包含对象与容器对象之间的依赖关系比较少)
		每一个类只专注于一项任务
		通过获取指向其它的具有相同类型的对象引用,可以在运行期间动态地定义(对象的)组合
	缺点:
		从而导致系统中的对象过多。
		为了能将多个不同的对象作为组合块来使用,必须仔细地对接口进行定义

继承特点:
	(类)继承是一种通过扩展一个已有的对象的实现,从而获取新功能的服用方法
	泛化类(超类)可以显式捕获那么公共的属性和方法
	特殊类(子类)则通过附加属性和方法来进行实现的扩展
继承的优点和缺点:
	优点:
		容易进行新的实现,因为大多数可继承而来
		易于修改或扩展那么被复用的实现
	缺点:
		破坏了封装性,因为这会将父类的实现细节暴露给子类
		"白盒"复用,因为父类的内部细节对于子类而言通常是可见的
		当父类的实现更改时,子类也不得不随之更改
		从父类继承来的实现将不能在运行期间进行改变
继承规则:仅当下列的所有标准被满足时，方可使用继承
	子类表达了是一个某某特殊类型,而非是一个由某某所扮演的角色
	子类的一个实例永远不需要转化为其它类的一个对象
	子类是对其父类的职责进行扩展,而非重写或废除
	子类没有对那些仅作为一个工具类的功能进行扩展
	对于一个位于实际的问题域的类而言,其子类特指一种角色,交易或设备

针对接口编程,而非(接口的)实现

接口的特征:
	接口是一个对象在对其它的对象进行调用时所知道的方法集合
	一个对象可以有多个接口(实际上,接口是对象所有方法的一个子集)
	类型是对象的一个特定的接口
	不同的对象可以具有相同的类型,而且一个对象可以具有多个不同的类型
	一个对象仅能通过其接口才会被其它对象所了解
	某种意义上,接口是以一种非常局限的方式,将是一种某某表达为一种支持该接口的某某
	接口是实现插件化的关键 
	接口表示某某像某某的关系,继承表示某某是某某的关系,组合表示某某有某某的关系
	
实现继承和接口继承:
	实现继承(类继承):一个对象的实现是根据另一个对象的实现来定义的
	接口继承(子类型化):描述了一个对象可在什么时候被用来替代另一个对象
	C++的继承机制既指类继承,又指接口继承
	C++通过继承纯虚类来实现接口继承
	Java对接口继承具有单独的语言构造方式－Java接口
	Java接口构造方式更加易于表达和实现那些专注于对象接口的设计
	 
接口的优点和缺点
	优点: 
		Client不必知道其使用对象的具体所属类
		一个对象可以很容易地被(实现了相同接口的)的另一个对象所替换
		对象间的连接不必硬绑定到一个具体类的对象上,因此增加了灵活性
		松散藕合
		增加了重用的可能性
		提高了(对象)组合的机率,因为被包含对象可以是任何实现了一个指定接口的类 
	缺点:
		设计的复杂性略有增加

类的封闭性原则

完备性:
	一个类要完成一个独立的业务过程,该类的内部应该定义了这个业务的整个过程,
	尽量不要在这个类定义了一些过程,而在另一个类中又定义了另外一些过程
透明性:
	一个类要提供一项功能给其他的类复用,该项功能对其使用者是透明的,
	不但是在实现上是透明的,而且在使用上也是透明的 

封闭性原则在类继承中运用
	类的继承形式:
		直接继承父类的方法实现复用
		调用父类的方法构成自己的方法实现复用
		通过抽象方法来实现逻辑关系的复用

案例:

class Vechile {
	//滚动的实现代码
	protected void roll() {}
}
class Car extends Vechile {
	public void driver() {}
	public static void main(String[] args) {
		Car bmw=new Car();
		bmw.driver();
		bmw.roll();//最终调用者需要知道开动汽车的所有操作方法
	}
}
/***************************************************/
class Vechile {
	//实现驱动功能代码
	protected void roll() {}
}
class Car extends Vechile {  
	public void go() {
		//调用父类的轮子滚动方法
		roll();
	}
	public static void main(String[] args) {
		Car bmw=new Car();
		bmw.go();//最终调用者只需知道一个开动汽车的方法
	}
}
/***************************************************/
abstract class Vechile {
	private void roll() {
		//实现滚动功能
	}
	//抽象的驱动方法
	protected abstract void drive();
	public void go() {
		//汽车的开动过程在这里完全定义,符合完备性原则
		drive();//驱动
		roll();//滚动
	}
}
class Car extends Vechile {
	//实现父类的抽象的驱动方法
	protected void drive() {
		//子类需要自己的驱动
	}
	public static void main(String[] args) {
		Vechile v = new Car();
		v.go();//调用车辆行驶功能
	}
}

开放-封闭法则(OCP)

开放-封闭法则认为我们应该试图去设计出永远也不需要改变的模块
我们可以添加新代码来扩展系统的行为.我们不能对已有的代码进行修改
符合OCP的模块需满足两个标准:
	可扩展,即对扩展是开放的模块的行为可以被扩展,以需要满足新的需求
	不可更改,即对更改是封闭的模块的源代码是不允许进行改动的

Liskov替换法则(LSP)

使用指向基类(超类)的引用的函数,必须能够在不知道具体派生类(子类)对象类型的情况下使用它们 
使用基类的地方,用该基类的所有子类替换基类,都应该保证程序是正确的