设计模式笔记：工厂模式，建造者模式

工厂模式：

我的理解：

工厂类（可抽象出来，弄好几个工厂实例）内部创建产品（必须抽象，有好多不同实现），把创建好的产品输出。这样使用的时候就只要调用工厂（不同工厂的产品不同）的生产产品方法就可以返回一个产品。

应用场景：

    在一个公用的方法内要新建不同的产品进行操作时可以使用。

//这里如果新增加产品的种类，只需要实现工厂和产品类，不影响整个公共方法的任何代码

//如果只是使用抽象对象的方法，则在方法内是不能创建该对象的（虽然可以操作）

public void function (parameter1,parameter2,abstractfactory){

....

abstractproduct = abstractfactory.createabstractfactory;

....

}

    还有一个地方可以用到：当创建的对象的初始化非常复杂的时候可以使用。

---

1. 概念

    工厂方法：一抽象产品类派生出多个具体产品类；一抽象工厂类派生出多个具体工厂类；每个具体工厂类只能创建一个具体产品类的实例。

    即定义一个创建对象的接口（即抽象工厂类），让其子类（具体工厂类）决定实例化哪一个类（具体产品类）。“一对一”的关系。

 

    抽象工厂：多个抽象产品类，派生出多个具体产品类；一个抽象工厂类，派生出多个具体工厂类；每个具体工厂类可创建多个具体产品类的实例。

    即提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们的具体的类。“一对多”的关系。

2. UML

 工厂方法：

抽象工厂：

3. 代码

静态工厂：

public class Factory{

public static ISample creator(int which){

if (which==1)

return new SampleA();

else if (which==2)

return new SampleB();

}

}

工厂方法：

public interface Product

{

}

public interface Creator  

{

public Product factory();

}

public class ConcreteProduct1 implements Product  

{

public ConcreteProduct1()

{

System.out.println("ConcreteProduct1被创建");

}

}

public class ConcreteProduct2 implements Product  

{

public ConcreteProduct2()

{

System.out.println("ConcreteProduct2被创建");

}

}

public class ConcreteCreator1 implements Creator  

{

public Product factory()

{

return new ConcreteProduct1();

}

}

public class ConcreteCreator2 implements Creator  

{

public Product factory()

{

return new ConcreteProduct2();

}

}

public class Client

{

private static Creator creator1, creator2;

private static Product prod1, prod2;

 

public static void main(String[] args)

{

creator1 = new ConcreteCreator1();

prod1 = creator1.factory();

System.out.println("----------------------------");

creator2 = new ConcreteCreator2();

prod2 = creator2.factory();

}

}

抽象工厂：

 //定义不同的产品之间的一定具备的标准，用interface实现 

//其中的method()方法可看作提取出不同产品的共性，如手机都有类似的功能

interface IProductA{

public void method();

}

interface IProductB {  

public void method();

}

//实现了产品标准实现的一系列具体产品  

//由于已经设计好A1由厂商1生产，故以下输出代码有“厂商x”

class ProductA1 implements IProductA{

public void method() {

System.out.println("厂商1 生产ProductA1 ...");

}

}

class ProductA2 implements IProductA {  

public void method() {

System.out.println("厂商2 生产ProductA2 ...");

}

}

class ProductB1 implements IProductB {  

public void method() {

System.out.println("厂商1 生产ProductB1 ...");

}

}

class ProductB2 implements IProductB {  

public void method() {

System.out.println("厂商2 生产ProductB2 ...");

}

}

//每一种牌子的产品生产工厂，即不同的厂商负责自己牌子产品的生产  

abstract class Factory1{

abstract IProductA getProductA1();

abstract IProductB getProductB1();

}

abstract class Factory2 {  

abstract IProductA getProductA2();

abstract IProductB getProductB2();

}

//具体的工厂用来生产相关的产品  

class ConcreteFactory1 extends Factory1{

public IProductA getProductA1() {

return new ProductA1();

}

public IProductB getProductB1() {

return new ProductB1();

}

}

 

class ConcreteFactoryB extends Factory2{

public IProductA getProductA2() {

return new ProductA2();

}

public IProductB getProductB2() {

return new ProductB2();

}

}

 

//测试类

public class Client {

public static void main(String[] args) {

//厂商1负责生产产品A1、B1

Factory1 factory1 = new ConcreteFactory1();

IProductA productA1 = factory1.getProductA1();

IProductB productB1 = factory1.getProductB1();

productA1.method();

productB1.method();

//厂商2负责生产产品A2、B2

Factory2 factory2 = new ConcreteFactoryB();

IProductA productA2 = factory2.getProductA2();

IProductB productB2 = factory2.getProductB2();

productA2.method();

productB2.method();

}

}

4. 应用场景

工厂方法：

在以下情况下，适用于工厂方法模式：

(1) 当一个类不知道它所必须创建的对象的类的时候。

(2) 当一个类希望由它的子类来指定它所创建的对象的时候。

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

抽象工厂：

(1) 一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节，这对于所有形态的工厂模式都是重要的。

(2) 这个系统有多于一个的产品族，而系统只消费其中某一产品族。

(3) 同属于同一个产品族的产品是在一起使用的，这一约束必须在系统的设计中体现出来。

(4) 系统提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于实现。

来源： http://www.cnblogs.com/devinzhang/archive/2011/12/19/2293160.html

2016年3月

---

创建者模式

我的理解：

    先定义好一个产品的创建步骤作为抽象类（builder 里面包含产品product），然后各个产品实现类实现每一个创建步骤，接着就是创建者(定义了创建对象的创建步骤的顺序）执行创建方法。这个时候产品已经创建好了，使用builder实现类的 getResult（） 方法吧产品弄出来。

使用场景：

    产品类的创建超级复杂，还要有固定的创建步骤。的时候使用

1.把做一件事情所有的步骤作为抽象函数写到接口Builder中；

2.在实现类中重写所有抽象函数；

3.将建造者对象传递给指挥者，让指挥者依次执行所有的步骤；

4.通过Product的getProduct()，获取最后生成的对象。

代码：

public interface Builder {

　　　　void buildPartA();

　　　　void buildPartB();

　　　　void buildPartC();

　　

　　　　Product getResult();

　　}

//具体建造工具

　　public class ConcreteBuilder implements Builder {

　　　　Part partA, partB, partC;

 

　　　　public void buildPartA() {

　　　　　　//这里是具体如何构建partA的代码

　　　　};

　　　　public void buildPartB() {

　　　　　　//这里是具体如何构建partB的代码

　　　　};

　　　　 public void buildPartC() {

　　　　　　//这里是具体如何构建partB的代码

　　　　};

　　　　 public Product getResult() {

　　　　　　//返回最后组装成品结果

　　　　};

　　}

//建造者

　　public class Director {

　　　　private Builder builder;

　　

　　　　public Director( Builder builder ) {

　　　　　　this.builder = builder;

　　　　}

　　　　public void construct() {

　　　　　　builder.buildPartA();

　　　　　　builder.buildPartB();

　　　　　　builder.buildPartC();

　　　　}

　　}

　　public interface Product { }

　　public interface Part { }

--下面是调用builder的方法：

　　ConcreteBuilder builder = new ConcreteBuilder();

　　Director director = new Director( builder );

　　

　　director.construct();

　　Product product = builder.getResult();