《设计模式》笔记之几种重要的设计模式

正在学习《设计模式》，其中的代码是自己理解该模式后YY而成,最后一个参考了《java设计模式》中的例子，仅供参考，欢迎指正。

1、抽象工厂（Abustact Factory）

1)意图：提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们具体的类。

2)适用性：在以下情况下可以使用Abstract Factory模式

一个系统要独立于它的产品的创建、组合和表示。（即后台与前台分开表示）

一个系统要由多个产品系列中的一个来配置时。（即有多重可选情况时）

当你要强调一系列相关产品对象的设计以便进行联合使用时。（即每一种设计都由多个组件组合而成）

当你提供一个产品类库，而只想显示它们的接口而不是实现时。（即抽象产品内核，提供外部接口时）

3）结构：如下图

用户在创建产品时，可以选择工厂1，也可以选择工厂2，每个工厂都由不同的产品组件组合而成，用户只需要选择哪种组合方式，而无需关心每个产品的具体实现。

比如说，现在生产一个篮球，工厂A生产耐克篮球，工厂B生产阿迪达斯篮球，但面对用户的只有一个“生产篮球”接口，用户只需要传入“生产XXXX篮球”的参数进入，就可以得到想要的篮球。两种产品共用了一个入口。

4）代码：

       建立一个“抽象工厂”的抽象类；

public abstract class AbstractFactory {
	public abstract ProductA CreatProductA();
	
	public abstract ProductB CreatProductB();
}

       两种工厂分别继承抽象类；

public class Factory1 extends AbstractFactory {
	public ProductA CreatProductA() {
		ProductA product1A=new ProductA();
		System.out.println("工厂1制作产品A");
		return product1A;
	}
	
	public ProductB CreatProductB() {
		ProductB product1B=new ProductB();
		System.out.println("工厂1制作产品B");
		return product1B;
	}
}

public class Factory2 extends AbstractFactory {
	public ProductA CreatProductA() {
		ProductA product2A=new ProductA();
		System.out.println("工厂2制作产品B");
		return product2A;
	}
	
	public ProductB CreatProductB() {
		ProductB product2B=new ProductB();
		System.out.println("工厂2制作产品B");
		return product2B;
	}
}

有一个产品类，用于生成不同类型的产品以及其中的不同部件；

public class Product {
	private	ProductA productA;
	private ProductB productB;
	
	public void add(ProductA productA) {
		this.productA=productA;
	}
	public void add(ProductB productB) {
		this.productB=productB;
	}
	
	public static Product createProduct(AbstractFactory factory) {
		Product product=new Product();
		product.add(factory.CreatProductA());
		product.add(factory.CreatProductB());
		System.out.println(factory+"产品已经完成");
		return product;
	}
}

ProductA和ProductB中没有内容，只是空的类，这里不再写出。最后是测试：

public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Factory1 factory1=new Factory1();
		Product.createProduct(factory1);
		Factory2 factory2=new Factory2();
		Product.createProduct(factory2);
	}

}

2.生成器（Buider）

1)意图：将一个复杂对象的构建和他的表示分离，使得同样的构造过程可以创建不同的表示。

2)适用性：

当创建复杂对象的算法应该独立于该对象的组成部分以及他们的装配方式时；

当构造过程必须允许被构造的对象有不同的表示时。

3）结构：如下图

4)协作：

客户创建Director对象，并用让它生成想要的Builder对象进行配置。

一旦产品部件被生成，导向器就会通知生成器。

声称其处理导向器的请求，并将部件产品添加到该产品中。

客户从生成器中检索产品。

下面的交互图说明了Builder和Director是如何与一个客户协作的。

5）代码：

定义一个Buidler接口，他不做任何实际的生成。

public interface Builder {
	public void BuildWhole();
	public void BuildPart1(int number);
	public void BuildPart2(String str);
	}

用两种不同的表现来实现这个接口

public class GreatBuilder implements Builder {

	@Override
	public void BuildWhole() {
		// TODO Auto-generated method stub
		System.out.println("GreatBuilderWhole");
	}

	@Override
	public void BuildPart1(int number) {
		// TODO Auto-generated method stub
		System.out.println("GreatBuilderPart1:"+number);

	}

	@Override
	public void BuildPart2(String str) {
		// TODO Auto-generated method stub
		System.out.println("GreatBuilderPart2:"+str);

	}

}

public class NormalBuilder implements Builder {

	/* (non-Javadoc)
	 * @see designpattern.Builder#BuildWhole()
	 */
	@Override
	public void BuildWhole() {
		// TODO Auto-generated method stub
		System.out.println("NormalBuilderWhole");

	}

	/* (non-Javadoc)
	 * @see designpattern.Builder#BuildPart1(int)
	 */
	@Override
	public void BuildPart1(int number) {
		// TODO Auto-generated method stub
		System.out.println("NormalBuilderPart1:"+number);

	}

	/* (non-Javadoc)
	 * @see designpattern.Builder#BuildPart2(java.lang.String)
	 */
	@Override
	public void BuildPart2(String str) {
		// TODO Auto-generated method stub
		System.out.println("NormalBuilderPart2:"+str);

	}

}

       再分别用两种不同的构造实现产品的装配：

public class WholeProductA {
	public void CreateProduct(Builder builder) {
		builder.BuildWhole();
		builder.BuildPart1(1);
		builder.BuildPart1(2);
		builder.BuildPart2("部件2");
		
	}
}

public class WholeProductB {
	public void CreateProduct(Builder builder) {
		builder.BuildWhole();
		builder.BuildPart1(100);
		builder.BuildPart1(200);
		builder.BuildPart2("一种部件2");
		builder.BuildPart2("另一种部件2");
		
	}
}

下面是测试用例：

共有四种组合

public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		WholeProductA productA=new WholeProductA();
		WholeProductB productB=new WholeProductB();
		NormalBuilder normalBuilder=new NormalBuilder();
		GreatBuilder greatBuilder=new GreatBuilder();
		productA.CreateProduct(normalBuilder);
		productB.CreateProduct(normalBuilder);
		productA.CreateProduct(greatBuilder);
		productB.CreateProduct(greatBuilder);
	}

}

3.工厂方法（Factory Method）

1)意图：顶一个用于创建对象的接口，让子类将决定实例化哪一个类。Factory Method是一个类的实例化延迟到其子类。

2）适用性：

当一个类不知道他说必须创建的对象的类的时候。

当一个类希望由他的子类来制定他所创建的对象的时候。

        当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候。
3）结构：

4）协作：

Creator依赖于它的子类来定义工厂方法，所以他返回一个适当的ConcreteProduct实例。

5）例子

*roduct

public interface Work {

    void doWork();

}

ConcreteProduct

public class StudentWork implements Work {

    public void doWork() {

        System.out.println("学生*作业!");

    }

}

public class TeacherWork implements Work {

    public void doWork() {

        System.out.println("老师审批作业!");

    }

}

Creator

public interface IWorkFactory {

    Work get*ork();

}

Concre*eCreator

pu*lic class StudentWorkFactory implements IWorkFactory {

    public Work getWork() {

        *eturn new StudentWork();

    }

}

public class TeacherWorkFactory implements IWorkFactory {

    public Work getWork() {

        return new TeacherWork();

    }

}

Test

public class Test {

    public static void m*in(Strin*[] args) {

        IWorkFactory studentWorkFactory = new StudentWorkFactory();

        studentWorkFactory.getWork().d*Work();

        IWorkFactory teacherWorkFactory * new TeacherWorkFactory();

        teacherWorkFactory.g*tWork().*oWork();

    }

}

result

学生做作业!

老师审批作业!