设计原则与设计模式

设计原则

一、单一职责原则：一个类只负责一个功能领域中的相应职责，或者可以定义为：就一个类而言，应该只有一个引起它变化的原因。

二、接口隔离原则：使用多个专门的接口，而不使用单一的总接口，即客户端不应该依赖那些它不需要的接口。

三、依赖倒置原则：面向接口编程而不是面向实现类

• 高层组件不应该依赖低层组件，二者都应该依赖抽象（高层组件是由底层组件定义的行为类而不是对低层组件的抽象）
• 抽象不应该依赖于实现，实现应该依赖抽象
• 中心思想是面向接口编程

四、里氏替换原则：所有引用基类（父类）的地方必须能透明地使用其子类的对象

(1)子类的所有方法必须在父类中声明，或子类必须实现父类中声明的所有方法。根据里氏代换原则，为了保证系统的扩展性，在程序中通常使用父类来进行定义，如果一个方法只存在子类中，在父类中不提供相应的声明，则无法在以父类定义的对象中使用该方法。
  (2)  我们在运用里氏代换原则时，尽量把父类设计为抽象类或者接口，让子类继承父类或实现父接口，并实现在父类中声明的方法，运行时，子类实例替换父类实例，我们可以很方便地扩展系统的功能，同时无须修改原有子类的代码，增加新的功能可以通过增加一个新的子类来实现。里氏代换原则是开闭原则的具体实现手段之一。
  (3) Java语言中，在编译阶段，Java编译器会检查一个程序是否符合里氏代换原则，这是一个与实现无关的、纯语法意义上的检查，但Java编译器的检查是有局限的。

五、开放封闭原则：对扩展开发对修改封闭

六、迪米特法则：不要和"陌生人"说话、只与你的直接朋友通信

• 朋友：对象本身（this），以参数形式传入当前对象方法中的对象，当前对象的成员对象（如果成员对象是集合则包含集合中的对象），当前对象创建的对象，当前对象创建的对象
• 如果两个对象不必直接通信，那么这两个对象就不应该发生任何直接的相互作用，如果其中一个对象需要调用另外一个对象的某个方法时，可以通过第三者转发这个调用

七：合成复用原则：多用组合少用继承

设计模式

一、创建型模式

• 简单工厂模式
  角色：
  1、工厂角色：提供了创建对象的静态方法

class Factory {
    //静态工厂方法
	public static Product getProduct(String arg) {
		Product product = null;
		if (arg.equalsIgnoreCase("A")) {
			product = new ConcreteProductA();
            //初始化设置product
		}
		else if (arg.equalsIgnoreCase("B")) {
			product = new ConcreteProductB();
            //初始化设置product
		}
		return product;
	}
}

2、抽象产品角色：

abstract class Product {
    //所有产品类的公共业务方法
    public void methodSame() {
        //公共方法的实现
    }
    //声明抽象业务方法
    public abstract void methodDiff();
}

3、具体产品角色

class ConcreteProduct extends Product {
    //实现业务方法
    public void methodDiff() {
        //业务方法的实现
    }
}

简单工厂可以通过XML文件配合反射进行优化，这也是Spring的IOC容器实现的原理。
缺点：
1、当由新的产品添加时需要修改简单工厂的代码
2、具体的产品和工厂耦合

• 工厂方法模式：
  角色：
  1、抽象工厂：工厂方法的抽象，方法的返回值是抽象产品

interface Factory {
    public Product factoryMethod();
}

2、抽象产品：

abstract class Product {
    //所有产品类的公共业务方法
    public void methodSame() {
        //公共方法的实现
    }
    //声明抽象业务方法
    public abstract void methodDiff();
}

3、具体工厂

class ConcreteFactory implements Factory {
    public Product factoryMethod() {
        return new ConcreteProduct();
    }
}

4、具体产品

class ConcreteProduct extends Product {
    //实现业务方法
    public void methodDiff() {
        //业务方法的实现
    }
}

• 抽象工厂模式：工厂方法模式中只能创建一个对象，而抽象工厂模式中一个工厂可以创建一个产品族
  角色：
  1、抽象工厂

abstract class AbstractFactory {
public abstract AbstractProductA createProductA(); //工厂方法一
public abstract AbstractProductB createProductB(); //工厂方法二
……
}

2、抽象产品

abstract class AbstractProductA {
    //所有产品类的公共业务方法
    public void methodSame() {
        //公共方法的实现
    }
    //声明抽象业务方法
    public abstract void methodDiff();
}
abstract class AbstractProductB {
    //所有产品类的公共业务方法
    public void methodSame() {
        //公共方法的实现
    }
    //声明抽象业务方法
    public abstract void methodDiff();
}
……

3、具体工厂

class ConcreteFactory1 extends AbstractFactory {
    //工厂方法一
public AbstractProductA createProductA() {
    return new ConcreteProductA1();
}
 
//工厂方法二
public AbstractProductB createProductB() {
    return new ConcreteProductB1();
}
……
}

4、具体产品

abstract class ProductA extends AbstractProductA {
    //所有产品类的公共业务方法
    public void methodSame() {
        //公共方法的实现
    }
    //声明抽象业务方法
    public abstract void methodDiff();
}
abstract class ProductB extends AbstractProductB {
    //所有产品类的公共业务方法
    public void methodSame() {
        //公共方法的实现
    }
    //声明抽象业务方法
    public abstract void methodDiff();
}
……

• 单例模式：
  1、饿汉式

public class Singleton {
	private static final Singleton singleton = new Singleton();
	private Singleton(){
	}
	public static Singleton getInstance(){
		return new Singleton();
	}
}

缺点：不能实现延时加载，单例对象在类初始化时就已经被创建。
2、懒汉式：

class LazySingleton { 
    private volatile static LazySingleton instance = null; 
 
    private LazySingleton() { } 
 
    public static LazySingleton getInstance() { 
        //第一重判断
        if (instance == null) {
            //锁定代码块
            synchronized (LazySingleton.class) {
                //第二重判断
                if (instance == null) {
                    instance = new LazySingleton(); //创建单例实例
                }
            }
        }
        return instance; 
    }
}

可以实验延时加载但加锁影响性能
3、Initialization Demand Holder (IoDH)

public class Singleton {
	private static class HolderClass {
		private final static Singleton singleton = new Singleton();
	}

	public static Singleton getInstance(){
		return HolderClass.singletonl
	}
}

• 原型模式：使用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
  创建方式：
  1、自己实现clone方法，创建对象

class ConcretePrototype implements Prototype
{
	private String  attr; //成员属性
	public void  setAttr(String attr)
	{
    	this.attr = attr;
	}
	public String  getAttr()
	{
    	return this.attr;
	}
	public Prototype  clone() //克隆方法
	{
    	Prototype  prototype = new ConcretePrototype(); //创建新对象
    	prototype.setAttr(this.attr);
    	return prototype;
	}
}

2、调用Object的clone方法，需要实现Cloneable接口，否则会抛出异常

class WeeklyLog implements Cloneable
{
	private  String name;
	private  String date;
	private  String content;
	public  void setName(String name) {
              this.name  = name;
	}
	public  void setDate(String date) {
              this.date  = date;
	}
	public  void setContent(String content) {
              this.content  = content;
	}
	public  String getName() {
              return  (this.name);
	}
	public  String getDate() {
              return  (this.date);
	}
	public  String getContent() {
              return  (this.content);
	}
     //克隆方法clone()，此处使用Java语言提供的克隆机制
 	public WeeklyLog clone()
	{
		Object obj = null;
		try
		{
			obj = super.clone();
			return (WeeklyLog)obj;     
		}
		catch(CloneNotSupportedException e)
		{
			System.out.println("不支持复制！");
			return null;
		}
	}
}

这只实现了浅拷贝，对应基本类型的变量拷贝了值，对于引用类型的变量只拷贝了引用。
3、深拷贝，先序列化再反序列化

class WeeklyLog implements Cloneable
{
	private  String name;
	private  String date;
	private  String content;
	public  void setName(String name) {
		this.name  = name;
	}
	public  void setDate(String date) {
		this.date  = date;
	}
	public  void setContent(String content) {
		this.content  = content;
	}
	public  String getName() {
		return  (this.name);
	}
	public  String getDate() {
		return  (this.date);
	}
	public  String getContent() {
		return  (this.content);
	}
   //克隆方法clone()，此处使用Java语言提供的克隆机制
   public WeeklyLog clone()
	{
		Object obj = null;
		try
		{
			obj = super.clone();
			return (WeeklyLog)obj;     
		}
		catch(CloneNotSupportedException e)
		{
			System.out.println("不支持复制！");
			return null;
		}
	}
}

4、深拷贝，先调用super.clone()方法然后再创建引用对象进行赋值。

class WeeklyLog implements Cloneable
{
	private  String name;
	private  String date;
	private  String content;
	public  void setName(String name) {
		this.name  = name;
	}
	public  void setDate(String date) {
		this.date  = date;
	}
	public  void setContent(String content) {
		this.content  = content;
	}
	public  String getName() {
		return  (this.name);
	}
	public  String getDate() {
		return  (this.date);
	}
	public  String getContent() {
		return  (this.content);
	}
	public WeeklyLog clone()
	{
		Object obj = null;
		try
		{
			obj = super.clone();
			obj .setName(this.getName().clone());
			obj .setDate(this.getDate().clone());
			obj .setContent(this.getConten().clone());
			return (WeeklyLog)obj;     
		}
		catch(CloneNotSupportedException e)
		{
			System.out.println("不支持复制！");
			return null;
		}
	}
}

• 建造者模式
  角色：
  1、Builder（抽象建造者）：一般包含buildPartX()方法和getResult()方法，buildPartX()用来创建各个部件，getResult()返回创建的对象。

abstract class Builder {
//创建产品对象
	protected  Product product=new Product(); 
	public  abstract void buildPartA();
	public  abstract void buildPartB();
	public  abstract void buildPartC();
	//返回产品对象
	public  Product getResult() {
		return  product;
	}
}

2、ConcreteBuilder（具体建造者）：Builder的实现类
3、Product（产品角色）：被构建的对象

class Product  {
	private  String partA; //定义部件，部件可以是任意类型，包括值类型和引用类型
	private  String partB;
	private  String partC;
	//partA的Getter方法和Setter方法省略
	//partB的Getter方法和Setter方法省略
	//partC的Getter方法和Setter方法省略
}

4、Director（指挥者）：负责对象的构建顺序

class Director {
	private  Builder builder;
		public  Director(Builder builder) {
		this.builder=builder;
	}
	public  void setBuilder(Builder builder) {
		this.builder=builer;
	}
	//产品构建与组装方法
	public Product construct() {
		builder.buildPartA();
		builder.buildPartB();
		builder.buildPartC();
		return builder.getResult();
	}
}

合并Builder和Director：由于可以将Director中的construc()方法直接写入Builder()

abstract class ActorBuilder
{
	protected static Actor actor = new  Actor();
	public  abstract void buildType();
	public  abstract void buildSex();
	public  abstract void buildFace();
	public  abstract void buildCostume();
	public  abstract void buildHairstyle();
	public static Actor  construct(ActorBuilder ab)
	{
		ab.buildType();
		ab.buildSex();
		ab.buildFace();
		ab.buildCostume();
		ab.buildHairstyle();
		return actor;
	}
}
//或者
abstract class ActorBuilder
{
	protected  Actor actor = new Actor();
	public  abstract void buildType();
	public  abstract void buildSex();
	public  abstract void buildFace();
	public  abstract void buildCostume();
	public  abstract void buildHairstyle();
	public Actor construct()
    {
		this.buildType();
		this.buildSex();
   		this.buildFace();
		this.buildCostume();
   		this.buildHairstyle();
		return actor;
	}
}

二、结构型模式：

• 适配器模式：
  角色：
  1、Target（目标抽象类）：客户所需要的接口
  2、Adapter（适配器类）：转换器

class Adapter extends Target {
	private Adaptee adaptee; //维持一个对适配者对象的引用
	
	public Adapter(Adaptee adaptee) {
		this.adaptee=adaptee;
	}
	//Target所拥有的方法
	public void request() {
		adaptee.specificRequest(); //转发调用
	}
}

3、Adaptee（适配者类）：被适配的角色，需要被调用的接口

• 桥接模式：将抽象部分与它的实现部分分离，使它们都可以独立地变化。
  角色：
  1、Abstraction（抽象类）：用于定义抽象类的接口，它一般是抽象类而不是接口，其中定义了一个Implementor（实现类接口）类型的对象并可以维护该对象，它与Implementor之间具有关联关系，它既可以包含抽象业务方法，也可以包含具体业务方法。

abstract class Abstraction {
	protected Implementor impl; //定义实现类接口对象
	public void setImpl(Implementor impl) {
		this.impl=impl;
	}
	public abstract void operation();  //声明抽象业务方法
}

2、RefinedAbstraction（扩充抽象类）：扩充由Abstraction定义的接口，通常情况下它不再是抽象类而是具体类，它实现了在Abstraction中声明的抽象业务方法，在RefinedAbstraction中可以调用在Implementor中定义的业务方法。

class RefinedAbstraction extends Abstraction {
	public void operation() {
		//业务代码
		impl.operationImpl();  //调用实现类的方法
		//业务代码
	}
}

3、Implementor（实现类接口）：定义实现类的接口，这个接口不一定要与Abstraction的接口完全一致，事实上这两个接口可以完全不同，一般而言，Implementor接口仅提供基本操作，而Abstraction定义的接口可能会做更多更复杂的操作。Implementor接口对这些基本操作进行了声明，而具体实现交给其子类。通过关联关系，在Abstraction中不仅拥有自己的方法，还可以调用到Implementor中定义的方法，使用关联关系来替代继承关系。

interface Implementor {
	public void operationImpl();
}

4、ConcreteImplementor（具体实现类）：具体实现Implementor接口，在不同的ConcreteImplementor中提供基本操作的不同实现，在程序运行时，ConcreteImplementor对象将替换其父类对象，提供给抽象类具体的业务操作方法。

class RefinedAbstraction extends Abstraction {
	public void operation() {
		//业务代码
		impl.operationImpl();  //调用实现类的方法
		//业务代码
	}
}

• 组合模式：组合多个对象形成树形结构以表示具有“整体—部分”关系的层次结构。组合模式对单个对象（即叶子对象）和组合对象（即容器对象）的使用具有一致性。
  角色：
  1、Component（抽象构件）：它可以是接口或抽象类，为叶子构件和容器构件对象声明接口，在该角色中可以包含所有子类共有行为的声明和实现。在抽象构件中定义了访问及管理它的子构件的方法，如增加子构件、删除子构件、获取子构件等。

abstract class Component {
	public abstract void add(Component c); //增加成员
	public abstract void remove(Component c); //删除成员
	public abstract Component getChild(int i); //获取成员
	public abstract void operation();  //业务方法
}

2、 Leaf（叶子构件）：它在组合结构中表示叶子节点对象，叶子节点没有子节点，它实现了在抽象构件中定义的行为。对于那些访问及管理子构件的方法，可以通过异常等方式进行处理。

class Leaf extends Component {
	public void add(Component c) { 
		//异常处理或错误提示 
	}	
		
	public void remove(Component c) { 
		//异常处理或错误提示 
	}
	
	public Component getChild(int i) { 
		//异常处理或错误提示
		return null; 
	}
	
	public void operation() {
		//叶子构件具体业务方法的实现
	} 
}

3、Composite（容器构件）：它在组合结构中表示容器节点对象，容器节点包含子节点，其子节点可以是叶子节点，也可以是容器节点，它提供一个集合用于存储子节点，实现了在抽象构件中定义的行为，包括那些访问及管理子构件的方法，在其业务方法中可以递归调用其子节点的业务方法。

class Composite extends Component {
	private ArrayList<Component> list = new ArrayList<Component>();
	
	public void add(Component c) {
		list.add(c);
	}
	
	public void remove(Component c) {
		list.remove(c);
	}
	
	public Component getChild(int i) {
		return (Component)list.get(i);
	}
	
	public void operation() {
		//容器构件具体业务方法的实现
        //递归调用成员构件的业务方法
		for(Object obj:list) {
			((Component)obj).operation();
		}
	} 	
}

• 装饰者模式
  1、Component（抽象构件）：它是具体构件和抽象装饰类的共同父类，声明了在具体构件中实现的业务方法，它的引入可以使客户端以一致的方式处理未被装饰的对象以及装饰之后的对象，实现客户端的透明操作。
  2、ConcreteComponent（具体构件）：它是抽象构件类的子类，用于定义具体的构件对象，实现了在抽象构件中声明的方法，装饰器可以给它增加额外的职责（方法）。
  3、Decorator（抽象装饰类）：它也是抽象构件类的子类，用于给具体构件增加职责，但是具体职责在其子类中实现。它维护一个指向抽象构件对象的引用，通过该引用可以调用装饰之前构件对象的方法，并通过其子类扩展该方法，以达到装饰的目的。

class Decorator implements Component
{
	private Component component;  //维持一个对抽象构件对象的引用
	public Decorator(Component component)  //注入一个抽象构件类型的对象
	{
		this.component=component;
	}
	public void operation()
	{
		component.operation();  //调用原有业务方法
	}
}

4、ConcreteDecorator（具体装饰类）：它是抽象装饰类的子类，负责向构件添加新的职责。每一个具体装饰类都定义了一些新的行为，它可以调用在抽象装饰类中定义的方法，并可以增加新的方法用以扩充对象的行为。

class ConcreteDecorator extends Decorator
{
	public ConcreteDecorator(Component  component)
	{
		super(component);
	}
	public void operation()
	{
		super.operation();  //调用原有业务方法
		addedBehavior();  //调用新增业务方法
	}
     //新增业务方法
	public  void addedBehavior()
	{    
		……
	}
}

• 外观模式：为子系统中的一组接口提供一个统一的入口。外观模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。
  角色：
  1、Facade（外观角色）：在客户端可以调用它的方法，在外观角色中可以知道相关的（一个或者多个）子系统的功能和责任；在正常情况下，它将所有从客户端发来的请求委派到相应的子系统去，传递给相应的子系统对象处理。

class Facade
{
    private SubSystemA obj1 = new SubSystemA();
    private SubSystemB obj2 = new SubSystemB();
    private SubSystemC obj3 = new SubSystemC();
 
    public void Method()
    {
        obj1.MethodA();
        obj2.MethodB();
        obj3.MethodC();
    }
}

2、SubSystem（子系统角色）：在软件系统中可以有一个或者多个子系统角色，每一个子系统可以不是一个单独的类，而是一个类的集合，它实现子系统的功能；每一个子系统都可以被客户端直接调用，或者被外观角色调用，它处理由外观类传过来的请求；子系统并不知道外观的存在，对于子系统而言，外观角色仅仅是另外一个客户端而已。

class SubSystemA
{
    public void MethodA()
    {
        //业务实现代码
    }
}
 
class SubSystemB
{
    public void MethodB()
    {
        //业务实现代码
     }
}
 
class SubSystemC
{
    public void MethodC()
    {
        //业务实现代码
    }
}

• 代理模式：给某一个对象提供一个代理或占位符，并由代理对象来控制对原对象的访问。
  角色：
  1、Subject（抽象主题角色）：它声明了真实主题和代理主题的共同接口，这样一来在任何使用真实主题的地方都可以使用代理主题，客户端通常需要针对抽象主题角色进行编程。

abstract class Subject
{
    public abstract void Request();
}

2、Proxy（代理主题角色）：它包含了对真实主题的引用，从而可以在任何时候操作真实主题对象；在代理主题角色中提供一个与真实主题角色相同的接口，以便在任何时候都可以替代真实主题；代理主题角色还可以控制对真实主题的使用，负责在需要的时候创建和删除真实主题对象，并对真实主题对象的使用加以约束。通常，在代理主题角色中，客户端在调用所引用的真实主题操作之前或之后还需要执行其他操作，而不仅仅是单纯调用真实主题对象中的操作。

class Proxy implements Subject
{
    private RealSubject realSubject = new RealSubject(); //维持一个对真实主题对象的引用
 
    public void PreRequest() 
    {
        …...
    }
 
    public override void Request() 
    {
        PreRequest();
        realSubject.Request(); //调用真实主题对象的方法
         PostRequest();
    }
 
    public void PostRequest() 
    {
        ……
    }
}

3、RealSubject（真实主题角色）：它定义了代理角色所代表的真实对象，在真实主题角色中实现了真实的业务操作，客户端可以通过代理主题角色间接调用真实主题角色中定义的操作。

class RealSubject implements Subject
{
    public override void Request()
    {
        //业务方法具体实现代码
    }
}

三、行为型模式

• 职责链模式：避免请求发送者与接收者耦合在一起，让多个对象都有可能接收请求，将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止。职责链模式是一种对象行为型模式。
  角色：
  1、 Handler（抽象处理者）：它定义了一个处理请求的接口，一般设计为抽象类，由于不同的具体处理者处理请求的方式不同，因此在其中定义了抽象请求处理方法。因为每一个处理者的下家还是一个处理者，因此在抽象处理者中定义了一个抽象处理者类型的对象（如结构图中的successor），作为其对下家的引用。通过该引用，处理者可以连成一条链。

abstract class Handler {
	//维持对下家的引用
	protected Handler successor;
	public void setSuccessor(Handler successor) {
		this.successor=successor;
	}
	public abstract void handleRequest(String request);
}

2、ConcreteHandler（具体处理者）：它是抽象处理者的子类，可以处理用户请求，在具体处理者类中实现了抽象处理者中定义的抽象请求处理方法，在处理请求之前需要进行判断，看是否有相应的处理权限，如果可以处理请求就处理它，否则将请求转发给后继者；在具体处理者中可以访问链中下一个对象，以便请求的转发。

class ConcreteHandler extends Handler {
	public void handleRequest(String request) {
		if (请求满足条件) {
			//处理请求
		}
		else {
			this.successor.handleRequest(request);  //转发请求
		}
	}
}

• 命令模式：将一个请求封装为一个对象，从而让我们可用不同的请求对客户进行参数化；对请求排队或者记录请求日志，以及支持可撤销的操作。（也就是在Invoker和Receiver引入一个Command）
  角色：
  1、Command（抽象命令类）：抽象命令类一般是一个抽象类或接口，在其中声明了用于执行请求的execute()等方法，通过这些方法可以调用请求接收者的相关操作。

public abstract class Command {
	public abstract void execute();
}

2、ConcreteCommand（具体命令类）：具体命令类是抽象命令类的子类，实现了在抽象命令类中声明的方法，它对应具体的接收者对象，将接收者对象的动作绑定其中。在实现execute()方法时，将调用接收者对象的相关操作(Action)。

class ConcreteCommand extends Command {
	private Receiver receiver; //维持一个对请求接收者对象的引用
	public void execute() {
		receiver.action(); //调用请求接收者的业务处理方法action()
	}
}

3、Invoker（调用者）：调用者即请求发送者，它通过命令对象来执行请求。一个调用者并不需要在设计时确定其接收者，因此它只与抽象命令类之间存在关联关系。在程序运行时可以将一个具体命令对象注入其中，再调用具体命令对象的execute()方法，从而实现间接调用请求接收者的相关操作。

class Invoker {
	private Command command;
    //构造注入
	public Invoker(Command command) {
		this.command = command;
	}
    //设值注入
	public void setCommand(Command command) {
		this.command = command;
	}
	//业务方法，用于调用命令类的execute()方法
	public void call() {
		command.execute();
	}
}

4、Receiver（接收者）：接收者执行与请求相关的操作，它具体实现对请求的业务处理。

public class Receiver {
	public void action() {
		//具体操作
	}
}

• 迭代器模式：
  角色：
  1、Iterator（抽象迭代器）：它定义了访问和遍历元素的接口，声明了用于遍历数据元素的方法，例如：用于获取第一个元素的first()方法，用于访问下一个元素的next()方法，用于判断是否还有下一个元素的hasNext()方法，用于获取当前元素的currentItem()方法等，在具体迭代器中将实现这些方法。

interface Iterator {
	public void first(); //将游标指向第一个元素
	public void next(); //将游标指向下一个元素
	public boolean hasNext(); //判断是否存在下一个元素
	public Object currentItem(); //获取游标指向的当前元素
}

2、ConcreteIterator（具体迭代器）：它实现了抽象迭代器接口，完成对聚合对象的遍历，同时在具体迭代器中通过游标来记录在聚合对象中所处的当前位置，在具体实现时，游标通常是一个表示位置的非负整数。

public class ConcreteIterator implements Iterator {
	private ConcreteAggregate objects; //维持一个对具体聚合对象的引用，以便于访问存储在聚合对象中的数据
	private int cursor; //定义一个游标，用于记录当前访问位置
	public ConcreteIterator(ConcreteAggregate objects) {
		this.objects=objects;
	}
	public void first() {  ......  }
	public void next() {  ......  }
	public boolean hasNext() {  ......  }
	public Object currentItem() {  ......  }
}

3、Aggregate（抽象聚合类）：它用于存储和管理元素对象，声明一个createIterator()方法用于创建一个迭代器对象，充当抽象迭代器工厂角色。

interface Aggregate {
	Iterator createIterator();
}

4、ConcreteAggregate（具体聚合类）：它实现了在抽象聚合类中声明的createIterator()方法，该方法返回一个与该具体聚合类对应的具体迭代器ConcreteIterator实例。

class ConcreteAggregate implements Aggregate {	
    ......	
    public Iterator createIterator() {
	return new ConcreteIterator(this);
    }
	......
}

• 中介者模式(Mediator Pattern)：用一个中介对象（中介者）来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
  角色：
  1、Mediator（抽象中介者）：它定义一个接口，该接口用于与各同事对象之间进行通信。

abstract class Mediator {
	protected ArrayList<Colleague> colleagues; //用于存储同事对象
    //注册方法，用于增加同事对象
	public void register(Colleague colleague) {
		colleagues.add(colleague);
	}
	//声明抽象的业务方法
	public abstract void operation();
}

2、ConcreteMediator（具体中介者）：它是抽象中介者的子类，通过协调各个同事对象来实现协作行为，它维持了对各个同事对象的引用。

class ConcreteMediator extends Mediator {
    //实现业务方法，封装同事之间的调用
	public void operation() {
		......
		((Colleague)(colleagues.get(0))).method1(); //通过中介者调用同事类的方法
		......
	}
}

3、Colleague（抽象同事类）：它定义各个同事类公有的方法，并声明了一些抽象方法来供子类实现，同时它维持了一个对抽象中介者类的引用，其子类可以通过该引用来与中介者通信。

abstract class Colleague {
	protected Mediator mediator; //维持一个抽象中介者的引用
	
	public Colleague(Mediator mediator) {
		this.mediator=mediator;
	}
	
	public abstract void method1(); //声明自身方法，处理自己的行为
	
	//定义依赖方法，与中介者进行通信
	public void method2() {
		mediator.operation();
	}
}

4、ConcreteColleague（具体同事类）：它是抽象同事类的子类；每一个同事对象在需要和其他同事对象通信时，先与中介者通信，通过中介者来间接完成与其他同事类的通信；在具体同事类中实现了在抽象同事类中声明的抽象方法。

class ConcreteColleague extends Colleague {
	public ConcreteColleague(Mediator mediator) {
		super(mediator);
	}
    //实现自身方法
	public void method1() {
		......
	}
}

• 备忘录模式：在不破坏封装的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，这样可以在以后将对象恢复到原先保存的状态。
  角色：
  1、 Originator（原发器）：它是一个普通类，可以创建一个备忘录，并存储它的当前内部状态，也可以使用备忘录来恢复其内部状态，一般将需要保存内部状态的类设计为原发器。

package dp.memento;
public class Originator {
    private String state;
    public Originator(){}
　　// 创建一个备忘录对象
    public Memento createMemento() {
　　　　return new Memento(this);
    }
　　// 根据备忘录对象恢复原发器状态
    public void restoreMemento(Memento m) {
　　　　 state = m.state;
    }
    public void setState(String state) {
        this.state=state;
    }
    public String getState() {
        return this.state;
    }
}

2、Memento（备忘录)：存储原发器的内部状态，根据原发器来决定保存哪些内部状态。备忘录的设计一般可以参考原发器的设计，根据实际需要确定备忘录类中的属性。需要注意的是，除了原发器本身与负责人类之外，备忘录对象不能直接供其他类使用，原发器的设计在不同的编程语言中实现机制会有所不同。

package dp.memento;
//备忘录类，默认可见性，包内可见
class Memento {
    private String state;
    public Memento(Originator o) {
　　　　state = o.getState();
    }
    public void setState(String state) {
        this.state=state;
    }
    public String getState() {
        return this.state;
    }
}

3、Caretaker（负责人）：负责人又称为管理者，它负责保存备忘录，但是不能对备忘录的内容进行操作或检查。在负责人类中可以存储一个或多个备忘录对象，它只负责存储对象，而不能修改对象，也无须知道对象的实现细节。

package dp.memento;
public class Caretaker {
	private Memento memento;
	public Memento getMemento() {
		return memento;
	}
	public void setMemento(Memento memento) {
		this.memento=memento;
	}
}

• 观察者模式：定义对象之间的一种一对多依赖关系，使得每当一个对象状态发生改变时，其相关依赖对象皆得到通知并被自动更新。观察者模式的别名包括发布-订阅（Publish/Subscribe）模式、模型-视图（Model/View）模式、源-监听器（Source/Listener）模式或从属者（Dependents）模式。当Subject的状态发生改变时能通知观察者。
  角色：
  1、Subject（目标）：目标又称为主题，它是指被观察的对象。在目标中定义了一个观察者集合，一个观察目标可以接受任意数量的观察者来观察，它提供一系列方法来增加和删除观察者对象，同时它定义了通知方法notify()。目标类可以是接口，也可以是抽象类或具体类。

public interface Subject{
	public void registerObserver(Observer o);
	public void removeObserver(Observer o);
	public void notifyObservers();
}

2、ConcreteSubject（具体目标）：具体目标是目标类的子类，通常它包含有经常发生改变的数据，当它的状态发生改变时，向它的各个观察者发出通知；同时它还实现了在目标类中定义的抽象业务逻辑方法（如果有的话）。如果无须扩展目标类，则具体目标类可以省略。

public class ConcreteSubject{
	private ArrayList observers;
	private float field1;
	private float field2;
	private float field3;
	public ConcreteSubject(){
		observers = new ArrayList();
	}
	public void registerObserver(Observer o){
		observers.add(o);
	}
	public void removeObserver(Observer o){
		int i = observers.indexOf(o);
		if(i >= 0){
			observers.remove(i);
		}
	}
	public void notifyObservers(){
		for(int i = 0; i < observers.size(); i++){
			Observer ob = (Observer)observers.get(i);
			ob.update(field1, field2, field3);
		}
	}
}

3、Observer（观察者）：观察者将对观察目标的改变做出反应，观察者一般定义为接口，该接口声明了更新数据的方法update()，因此又称为抽象观察者。

public interface Observer{
	public void update(float field1, float field2, float field3);
}

4、ConcreteObserver（具体观察者）：在具体观察者中维护一个指向具体目标对象的引用，它存储具体观察者的有关状态，这些状态需要和具体目标的状态保持一致；它实现了在抽象观察者Observer中定义的update()方法。通常在实现时，可以调用具体目标类的attach()方法将自己添加到目标类的集合中或通过detach()方法将自己从目标类的集合中删除。

public ConcreteObserver implements Observer{
	private float field1;
	private float field2;
	private float field3;
	private Subject subject;
	public ConcreteObserver(Subject subject){
		this.subject = subject;
		subject.registerObserver(this);
	}
	public void update(field1, field2, field3){
		
	}
}

• 状态模式(State Pattern)：允许一个对象在其内部状态改变时改变它的行为，对象看起来似乎修改了它的类。其别名为状态对象(Objects for States)，状态模式是一种对象行为型模式。
  1、Context（环境类）：环境类又称为上下文类，它是拥有多种状态的对象。由于环境类的状态存在多样性且在不同状态下对象的行为有所不同，因此将状态独立出去形成单独的状态类。在环境类中维护一个抽象状态类State的实例，这个实例定义当前状态，在具体实现时，它是一个State子类的对象。

class Context {
	private State state; //维持一个对抽象状态对象的引用
	private int value; //其他属性值，该属性值的变化可能会导致对象状态发生变化
    //设置状态对象
	public void setState(State state) {
		this.state = state;
	}
	public void request() {
		//其他代码
		state.handle(); //调用状态对象的业务方法
		//其他代码
	}
}

2、State（抽象状态类）：它用于定义一个接口以封装与环境类的一个特定状态相关的行为，在抽象状态类中声明了各种不同状态对应的方法，而在其子类中实现类这些方法，由于不同状态下对象的行为可能不同，因此在不同子类中方法的实现可能存在不同，相同的方法可以写在抽象状态类中。

public abstract class State {
    //声明抽象业务方法，不同的具体状态类可以不同的实现
	public abstract void handle();
}

3、ConcreteState（具体状态类）：它是抽象状态类的子类，每一个子类实现一个与环境类的一个状态相关的行为，每一个具体状态类对应环境的一个具体状态，不同的具体状态类其行为有所不同。

class ConcreteState extends State {
	public void handle() {
		//方法具体实现代码
	}
}

• 策略模式：
  角色：
  1、 Context（环境类）：环境类是使用算法的角色，它在解决某个问题（即实现某个方法）时可以采用多种策略。在环境类中维持一个对抽象策略类的引用实例，用于定义所采用的策略。

class Context {
	private AbstractStrategy strategy; //维持一个对抽象策略类的引用
    public void setStrategy(AbstractStrategy strategy) {
        this.strategy= strategy;
    }
    //调用策略类中的算法
    public void algorithm() {
        strategy.algorithm();
    }
}

2、Strategy（抽象策略类）：它为所支持的算法声明了抽象方法，是所有策略类的父类，它可以是抽象类或具体类，也可以是接口。环境类通过抽象策略类中声明的方法在运行时调用具体策略类中实现的算法。

abstract class AbstractStrategy {
    public abstract void algorithm(); //声明抽象算法
}

3、ConcreteStrategy（具体策略类）：它实现了在抽象策略类中声明的算法，在运行时，具体策略类将覆盖在环境类中定义的抽象策略类对象，使用一种具体的算法实现某个业务处理。

class ConcreteStrategyA extends AbstractStrategy {
    //算法的具体实现
    public void algorithm() {
       //算法A
    }
}

• 模板方法模式：定义一个操作中算法的框架，而将一些步骤延迟到子类中。模板方法模式使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。
  角色：
  1、AbstractClass（抽象类）：在抽象类中定义了一系列基本操作(PrimitiveOperations)，这些基本操作可以是具体的，也可以是抽象的，每一个基本操作对应算法的一个步骤，在其子类中可以重定义或实现这些步骤。同时，在抽象类中实现了一个模板方法(Template Method)，用于定义一个算法的框架，模板方法不仅可以调用在抽象类中实现的基本方法，也可以调用在抽象类的子类中实现的基本方法，还可以调用其他对象中的方法。

abstract class AbstractClass 
{
	//模板方法
	public void TemplateMethod() 
	{
        PrimitiveOperation1();
        PrimitiveOperation2();
        PrimitiveOperation3();
	}
	//基本方法—具体方法
	public void PrimitiveOperation1() 
	{
		//实现代码
	}
	//基本方法—抽象方法
    public abstract void PrimitiveOperation2();    
	//基本方法—钩子方法
	public abstract boolean PrimitiveOperation3()   
	{  
	}
}

2、 ConcreteClass（具体子类）：它是抽象类的子类，用于实现在父类中声明的抽象基本操作以完成子类特定算法的步骤，也可以覆盖在父类中已经实现的具体基本操作。

class ConcreteClass : AbstractClass 
{
	public override void PrimitiveOperation2() 
	{
    	//实现代码
	}
	public override void PrimitiveOperation3() 
	{
    	//实现代码
	}
}

模板方法中的钩子方法：通过钩子方法来控制模板方法的逻辑，可以通过重写钩子方法来改变模板方法的逻辑。

……
//模板方法
public void TemplateMethod() 
{
	Open();
	Display();
	//通过钩子方法来确定某步骤是否执行
	if (IsPrint()) 
	{
    	Print();
	}
}
 
//钩子方法
public bool IsPrint()
{
    return true;
}
……

• MVC设计模式是一种混合设计模式，M指的是model，V指的是view，C指的是controller。
  角色：
  1、model：模型持有所有的数据、状态和程序逻辑
  2、view：用来呈现模型
  3、controller：取得用户的输入并解读其对模型的意识（controller并不负责处理逻辑，只是将用户的输入解读为对模型的操作，所有的逻辑和对数据的操作都交给model）
  一、非web应用中的MVC设计模式
  
  用户对view的操作交由controller，controller对用户的操作进行解析，并将解析后的操作交给model，model执行程序逻辑改变状态。view可以直接获取model的状态。当model的状态发生改变时，通知view改变界面，或者通知controller，让controller改变view。
  这好像和我们想的不太一样，model和view并没有完全的解耦，view可以直接获取model的转态，model也可以直接通知view改变转态。确实是这样的，只有当view改变模型的转态时，需要先有controller解析用户的操作，其实这样已经达到了软件复用的目的，模型可以作用于不同的view，view也可以改变不同的模型。
  MVC最主要使用了观察者模式和策略模式。view将用户行为发送给controller时使用了策略模式，一个view可能产生不同的用户行为，这时需要使用不同的controller，根据用户不同的行为替换不同的controller即可达到对应的目的。当model的状态发生改变时，需要通知视图或者controller，通过让model持有controller和view对象，在model的状态改变时通知model和view改变状态。在让我们来看看具体的java代码：
  Model对象

public class Model{
	private ArrayList<View> viewoOserveres = new ArrayList<View>();	//Model对象持有View对象来通知View对象改变状态
	private ArrayList<Controller> controllerOserveres = new ArrayList<Controller>();	//Model对象持有Controller对象来通知Controller对象改变状态
	public void notif(){
		for(View view : viewoOserveres)
			view.change();
		for(Controller controller : controllerOserveres)
			controller.change();
	}

	public void registerObserver(View view)
		viewoOserveres.add(view);
	public void registerController(Controller controller)
		controllerOserveres.add(controller);
	public void removeObserver(View view)
		viewoOserveres.remove(view);
	public void removeController(Controller controller)
		controllerOserveres.remove(controller);
	public void process(){
		//model的业务逻辑
	}
	public * get**(){}
}

View对象

public class View{
	private Controller controller;	//View对象持有controller，将用户的操作推送给controller
	private Model model;	//View对象持有model，获取model的状态
	public View(Controller controller, Model model){
		this.model = model;
		this.controller = controller;
		model.registerView(view);
	}
	public change(){
		set**(model.get**)	//获取用户的转态并且设置界面
	}
	public input(){
		controller.processs();
	}
	public void set**(){
	}
}

Controller

public class Controller{
	private View view;	//Controller持有view对象，通知view改变转态
	private Model model;	//Controller持有model对象，将解析后的操作发送个model
	public View(Model model){
		this.view= new View(this, model);
		this.model= model;
		model.registerView(this);
	}
	public change(){
		view.set**(model.get**)	//获取用户的转态并且设置界面
	}
	public process(){
		//解析用户请求
		model.process();
	}
}