设计原则与设计模式定义

从《深入浅出设计模式》摘录的设计原则：

1. 识别出应用变化的部分，并把其与不变的分离(封装变化)。Identify the aspects of your application that vary and seperate them form what stays the same.

 

2. 面向接口编程，不要面向实现编程。Program to an interface, not an implementation.

 

3. 多用组合，而不是继承。Favor composition over inheritance.

 

4. 在交互的对象间，尽量设计得松耦合。Strive for loosely coupled designs between objects that interact.

 

5. 类应该对扩展开放，对修改关闭。Classes should be open for extension, but closed for modification.

 

6. （依赖倒转原则）依赖抽象，不要依赖具体类。Depend upon abstractions. Do not depend upon concrete classes.（在工厂模式中，PizzaStore是高层组件，Pizza是低层组件，两者都应依赖抽象）

遵守原则6的方法：a.变量不可以持有具体类的引用（当用new时，就会持有具体类的引用，可用工厂避免）；b.不应让类派生自具体类（应派生自一个接口）；c.不要覆盖基类已实现的方法。在实现应用中，应尽量遵守这些原则，而不是完全遵守，也不可能完全遵守。

 

7.最少知识原则：只和你的密友谈话。Principle of Least Knowledge - talk only to your immediate friends.

 

8.荷里活原则：别调用我们，我们会调用你。The Hollywood Principle： Dont call us, we'll call you.

 

9.单一职责原则：一个类只应有一个导致它变化的原因。(cohesion 内聚力)a class should have only one reason to change.

 

 

 

 

号外：

依赖倒转原则和荷里活原则的区别：the dependency inversion principle teaches us to avoid the use of concrete classes and instead work as much as possible with abstractions. The Hollyhood principle is a technique for building frameworks or components so that lower-level components can be hooked into computation, but without creating dependencies between the lower-level components and th highter-level layers.

 

---------------------------------------------大家好 我是神圣分割线-----------------------------------------------------------

 

 

 

设计模式定义：

1.策略模式：定义一组算法家族，封装每个算法并使之可互换。策略模式让客户可以独立地应对算法的变化。defines a family of algorithms, encapsulates each one, and makes them interchangeable. Strategy lets the algorithm vary independently from clients that use it.

 

2.观察者模式：定义一对多的关系，当一个对象改变时，所有依赖者都会自动得到通知和更新。defines a one-to-many dependency between objects so that when one object changes state, all of its dependents are notified and updated automatically.

(Java内有Observable类和Observer接口，可实现。对于Observeable类相当于Subject，有Pull方式和Push方式。Pull是观察者主动取，Push是主题主动送数据。注意Observable是一个类，具体主题只能继承它，而Java又是单继承，会造成不便，另外Observable的setChanged()方法是protected，表明只能在子类中用，对于想用通过组合来使用observable是不可能的。所以对于Java内建的观察者模式要有取舍地用）

观察者模式在JDK中的应用：JavaBean和Swing。

 

3.装饰者模式：动态地给对象增加职责。装饰者提供一个比继承更有弹性的方案。attaches additional responsibilities to an object dynamically. Decorators provide a flexible alternative to subclassing for extending functionality.

装饰者可以在被委托的对象之前或之后，把它的行为加上，以完成剩下的任务。The decorator adds its own behavior either before or after delegating to the object it decorates to do the rest of the job.

在JDK中的应用：Java IO。

缺点：会造成大量的小类

 

4.工厂模式：定义生产对象的接口，但工厂方法让类的实例化延迟到子类决定。defines an interface for creating an object, but lets subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses. P.S. 工厂模式包含Creator和Product两个类。其中工厂方法不一定为抽象方法，可以定义一个默认工厂方法。

Creator中，工厂方法的一般格式: abstract Product createMethod(String type)

记住：工厂方法让子类决定实例化哪一个产品！与简单工厂不同的是：工厂方法提供一个通用的框架（或方法，例如代码中orderPizza()方法）来创建产品，其中对具体产品的创建过程延迟到子类执行（指代码中的抽象工厂方法createPizza()）。Factory Method lets subclass decide which class to instantiate. 而简单工厂只是封装创建产品的过程，未提供一个通用框架和实例化过程全在工厂内，没有所谓的子类。

 

5.抽象工厂模式：提供一个接口，用于创建相关或依赖对象的家族，而不需要指定它们的具体类。provides an interface for creating families of related or dependent objects without specifying their concrete classes.

客户可以用抽象接口来产生一组相关产品，而不需要关心实际产生的具体产品是什么。

 

6.单例模式：保证一个类只有一个实例，提供一个全局访问点。ensures a class has only one instance, and provides a global point of access to it.

 

7.命令模式：把“请求”封装成对象，以便使用不同的请求，队列或日志来参数化其对象。也支持可撤消操作。encapsulates a request as an object, thereby letting you parameterize other objects with different requests, queue or log requests, and support undoable operations.以下是命令模式中用到的术语解释：

Client: 用于产生命令对象

Command: 提供一个接口execute()，封装了调用Receiver的action()的过程。其具体类的常规格式，见代码：

	public void execute() {
		receiver.action();
	}

 

 

Invoker: 诉求者，调用setCommand(command_Obj)，并提供方法来调用command的execute方法。

Receiver: 包含一系列的action()，实际操作者。

(在书中，讲到一种Null Object的设计模式，当你不想在客户端逻辑中判断Null值时，可以通过设定默认对象为一个什么也不做的对象，如代码所示，表示一个什么也不做的Command)

public class NoCommand implements Command {
	@Override
	public void execute() {
		// do nothing
	}
}

 

7.适配器模式：把类的接口转换成客户期望的接口。适配器让那些因为不兼容接口的类可以合作无间。converts the interface of a class into another interface the clients expect. Adapter lets classes work together that couldn't otherwise because of incompatible interfaces.

 

8.装饰者模式：提供一个统一的接口，来访问子系统中的一群接口。外观定义了一个高层接口，让子系统更容易使用。provides a unified interface to a set of interfaces in a subsystem. facade defines a higher-level interface that makes the subsystems easier to use.

装饰者模式和适配器模式的区别，不在于包装多少个类，而是：两者的目的，适配器在于改变接口以匹配客户的期望；装饰者模式在于提供一个简化的接口。

 

9.模板方法模式：定义算法框架在一个方法里，某些步骤推迟到子类。模板方法让子类重定义算法的某些步骤，而不需要改变算法的结构。defines the skeleton of an algorithm in a method, deferring some steps to subclass. template method lets subclasses redefine certain steps of algorithm without changing the algorithm's structure.

在模板方法内，有三种类型的方法：primitiveOperation(),concreteOperation(),hook().对于ConcreteOperation一般为final，hook()方法是让子类覆盖的，也可以什么也不做，就是为了让子类选择性的覆盖。

 

10.迭代器模式：提供顺序访问聚合对象的元素的方法，而不需要暴露底层的实现。provides a way to access the elements of an aggregate object sequentially without exposing its underlying representation.

 

11.组合模式：允许你将对象组合成树形结构，来表现“部分与整体”的层次结构，组合能让客户以一致的方式处理个别对象以及对象组合。allows you to compose objects into tree structrues to represent part-whole hierarchies. Composite lets clients treat individual objects and compositions of objects uniformly.

 

12.状态模式：允许对象在内部状态改变时，改变它的行为。对象看起来就像修改了它的类。allows an object to alter its behavior when its internal state changes. the object will apear to change its class.

状态模式和策略模式的区别：类图是一样的，不过两者的目的不同。状态模式的行为改变是在State内进行的，封装行为在状态对象内，可以简单地在上下文中改变状态对象来改变行为。策略模式通过改变子类来改变行为。另外在初始化时，策略模式是客户自行定义的，在状态模式中通常有默认的状态，客户不需要知道状态。

 

13.代理模式：（参考rmi）

 

 

号外：

工厂模式和抽象工厂模式的联系与区别：

两者都是封装产生实例化对象的模式，更好地解耦和灵活的设计。

工厂模式通过继承产生对象；抽象工厂通过组合。就是工厂模式产生对象要通过继承Creator类并实现工厂方法（factory method)，用来产生相关对象。客户只需要知道抽象类工厂，而不用关心低层的具体工厂怎样产生产品的。而，抽象工厂模式提供一个产生“产品家族”的抽象类，其子类定义了产品被产生的方法。要用抽象工厂，就要实现化它并把它传入针对抽象类型所写的代码中。

抽象工厂可以把一组相关产品集合起来。缺点：当要增加一个产品时，要改抽象工厂的接口.

总的来说：抽象工厂用于稳定的产生一组产品家族，而工厂模式通过factory method只产生一种产品。