Java设计模式--- 创建型模式（Creational patterns）

1. 工厂模式（Factory）

通常情况下，利用static方法，我们使用静态工厂函数来获取对象。

interface Product{}
class A implements Product{}
class B implements Product{}

public class StaticFactory {
    public static Product getA(){  return new A(); }
    public static Product getB(){  return new B(); }
}
class myClient{
    public void get(String str){
        Product x = null ;
        if ( str.equals("A")) {
            x = StaticFactory.getA();
        }else if ( str.equals("B")){
            x = StaticFactory.getB();
        }
    }
}

这样客户端只需要传入相应的str就可以利用StaticFactory.getA()来获取一个Product对象了，不需要了解工厂里面的具体实现。

2. 抽象工厂模式（Abstract Factory）

抽象工厂比较灵活，当需要增加新的产品类的时候，只需要新增一个工厂类，就可以调用新类。而无需去改动原来的静态工厂里面的代码，使编程的可扩展性更强。如下实例所示：

interface Trace{}

class A implements Trace{}
class B implements Trace{}

interface Product{ Trace get();}

class FactoryA implements Product{
    @Override
    public Trace get() {
        return new A();
    }
}
class FactoryB implements Product{
    @Override
    public Trace get() {
        return new B();
    }
}

public class AbstractFactory {
    public void MyClient(){
        Trace x= new FactoryForA().get();
        Trace y = new FactoryForB().get();
    }
}

3. 建造者模式（Builder）

当客户端需要多个属性构成的一个整体对象的时候，用之前的Abstract Factory只能够得到一些零散的类对象，这就无法满足需求。所以这里使用Builder模式来应对这种情况。如下类图的关系：

例如如下的制造pizza的一个实例：

首先设计一个product类Pizza，如下：

/* "Product" */
class Pizza {
private String dough = "";
private String sauce = "";
private String topping = "";
public void setDough(String dough) {
this.dough = dough;
}
public void setSauce(String sauce) {
this.sauce = sauce;
}
public void setTopping(String topping) {
this.topping = topping;
}
}

然后设计一个Builder模式的抽象类，在里面设置需要不同对象实现的抽象方法：

abstract class PizzaBuilder {
protected Pizza pizza;
public Pizza getPizza() {
return pizza;
}
public void createNewPizzaProduct() {
pizza = new Pizza();
}
public abstract void buildDough();
public abstract void buildSauce();
public abstract void buildTopping();
}

然后用两个不同的实现方法的具体的类去继承它：

/* "ConcreteBuilder 1" */
class SpicyPizzaBuilder extends PizzaBuilder {
public void buildDough() {
pizza.setDough("pan baked");
}
public void buildSauce() {
pizza.setSauce("hot");
}
public void buildTopping() {
pizza.setTopping("pepperoni+salami");
}
}

/* "ConcreteBuilder 2" */
class HawaiianPizzaBuilder extends PizzaBuilder {
public void buildDough() {
pizza.setDough("cross");
}
public void buildSauce() {
pizza.setSauce("mild");
}
public void buildTopping() {
pizza.setTopping("ham+pineapple");
}
}

这样，两种不同的pizza制作方案类就出来了。当用户端waiter要运用它们使，接下来就要用到委派（delegation）关系了。

将这两种对象传进waiter类的构造函数里面，就可以在waiter类里面调用两种不同的pizza builder类的具体实现方法了。

waiter类如下：

class Waiter {
private PizzaBuilder pizzaBuilder;
public void setPizzaBuilder(PizzaBuilder pb) {
pizzaBuilder = pb;
}
public Pizza getPizza() {
return pizzaBuilder.getPizza();
}
public void constructPizza() {
pizzaBuilder.createNewPizzaProduct();
pizzaBuilder.buildDough();
pizzaBuilder.buildSauce();
pizzaBuilder.buildTopping();
}
}

然后，我们的客户端可以利用如下来调用相关的类：

public class PizzaBuilderDemo {
public static void main(String[] args) {
Waiter waiter = new Waiter();
PizzaBuilder hawaiianPizzabuilder = new HawaiianPizzaBuilder();
PizzaBuilder spicyPizzaBuilder = new SpicyPizzaBuilder();
waiter.setPizzaBuilder( hawaiianPizzabuilder );
waiter.constructPizza();
Pizza pizza = waiter.getPizza();
}
}

这个里面创建一个waiter对象，然后我们用两种不同的Pizzabuilder方案来构造两个Pizzabuilder对象hawaiianPizzabuilder和spicyPizzaBuilder。然后，利用委派关系，将builder类作为参数传入到waiter类对象里面，waiter.setPizzaBuilder( hawaiianPizzabuilder );然后就可以运用waiter类里面的方法来对两个Pizzabuilder对象进行操作了。