工厂模式

简单工厂模式

• UML: image.png

• 意图：简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（这些产品类继承自一个父类或接口）的实例。

• 主要解决：主要解决接口选择的问题，统一管理对象的创建。

• 优点：

  1:一个调用者想创建一个对象，只要知道其名称就可以了。
  2:扩展性高，如果想增加一个产品，只要修改工厂类就可以。
  3:屏蔽产品的具体实现，调用者只关心产品的接口。

• 缺点：

  1:违反了高内聚责任分配原则，将全部创建逻辑集中到了一个工厂类中
  2.如果需要添加新的类，则就需要改变工厂类

• 模型：披萨店点披萨

• 特点，披萨可能有很多种，有cheese，greek,pepper等，除了原料不同外，他们的制作过程类似。

//披萨抽象类
public abstract class Pizza {
    protected String name;
        //只有原材料不同
    public abstract void prepare();
    public void bake(){
        System.out.println(name+" baking;");
    }
    public void cut(){
        System.out.println(name+" cutting;");
    }
    public void box(){
        System.out.println(name+" boxing;");
    }
    public void setname(String name){
        this.name=name;
    }
}
public class GreekPizza extends Pizza {

    @Override
    public void prepare() {
        // TODO Auto-generated method stub
        super.setname("GreekPizza");
        
        System.out.println(name+" preparing;");
    }

}

public class CheesePizza extends Pizza {
    @Override
    public void prepare() {
        super.setname("CheesePizza");
        System.out.println(name+" preparing;");
    }
}
public class PepperPizza extends Pizza {
    @Override
    public void prepare() {
        super.setname("PepperPizza");   
        System.out.println(name+" preparing;");
    }
}

public class SimplePizzaFactory {
    public Pizza CreatePizza(String ordertype) {
        Pizza pizza = null;
        if (ordertype.equals("cheese")) {
            pizza = new CheesePizza();
        } else if (ordertype.equals("greek")) {
            pizza = new GreekPizza();
        } else if (ordertype.equals("pepper")) {
            pizza = new PepperPizza();
        }
        return pizza;
    }
}

简单工厂，仅仅是把对象的创建封装到工厂中，不对外暴露细节。

• 使用简单工厂：

public class OrderPizza {
    SimplePizzaFactory mSimplePizzaFactory;
        //注入工厂
    public OrderPizza(SimplePizzaFactory mSimplePizzaFactory) {
        setFactory(mSimplePizzaFactory);
    }
    public void setFactory(SimplePizzaFactory mSimplePizzaFactory) {
        Pizza pizza = null;
        String ordertype;
        this.mSimplePizzaFactory = mSimplePizzaFactory;
        do {
            ordertype = gettype();
            pizza = mSimplePizzaFactory.CreatePizza(ordertype);
            if (pizza != null) {
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            }
        } while (true);
    }
        //获取用户的需求
    private String gettype() {
        try {
            BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza type:");
            String str = strin.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }
}
//测试类
public class PizzaStroe {
    public static void main(String[] args) {
        SimplePizzaFactory mSimplePizzaFactory;
        OrderPizza mOrderPizza;
        mOrderPizza=new OrderPizza(new SimplePizzaFactory());
    }
}

工厂方法

• UML:

  
  image.png

• 意义：定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。

• 特点：工厂方法模式对简单工厂模式进行了抽象。有一个抽象的Factory类（可以是抽象类和接口），这个类将不再负责具体的产品生产，而是只制定一些规范，具体的生产工作由其子类去完成。在这个模式中，工厂类和产品类往往可以依次对应。即一个抽象工厂对应一个抽象产品，一个具体工厂对应一个具体产品，这个具体的工厂就负责生产对应的产品。

• 模型：不同的地域披萨店，例如，纽约有生产披萨的工厂，伦敦也有生产披萨的工厂，生产出来的披萨是纽约的或伦敦的。

public class LDCheesePizza extends Pizza {
    @Override
    public void prepare() {
        super.setname("LDCheesePizza");
        System.out.println(name+" preparing;");
    }
}
public class LDPepperPizza extends Pizza {
    @Override
    public void prepare() {
        super.setname("LDPepperPizza");
        System.out.println(name+" preparing;");
    }
}
public class NYPepperPizza extends Pizza {
    @Override
    public void prepare() {
        super.setname("NYPepperPizza");
        System.out.println(name+" preparing;");
    }
}
public class NYCheesePizza extends Pizza {
    @Override
    public void prepare() {
        super.setname("NYCheesePizza");
        System.out.println(name+" preparing;");
    }
}

public abstract class OrderPizza {
    public OrderPizza() {
        Pizza pizza = null;
        String ordertype;
        do {
            ordertype = gettype();
                        //这里抽象出创建产品的方法，由子类实现
            pizza = createPizza(ordertype);
                        .....
        } while (true);
    }
    abstract Pizza createPizza(String ordertype);
       ....
}
//抽象方法的实现类
public class LDOrderPizza extends OrderPizza {
    @Override
    Pizza createPizza(String ordertype) {
        Pizza pizza = null;
        if (ordertype.equals("cheese")) {
            pizza = new LDCheesePizza();
        } else if (ordertype.equals("pepper")) {
            pizza = new LDPepperPizza();
        }
        return pizza;
    }
}

public class NYOrderPizza extends OrderPizza {
    @Override
    Pizza createPizza(String ordertype) {
        Pizza pizza = null;
        if (ordertype.equals("cheese")) {
            pizza = new NYCheesePizza();
        } else if (ordertype.equals("pepper")) {
            pizza = new NYPepperPizza();
        }
        return pizza;
    }
}
//测试
public class PizzaStroe {
    public static void main(String[] args) {
        OrderPizza mOrderPizza;
               //创建不同地域的工厂就生产不同地域的披萨
        mOrderPizza=new NYOrderPizza(); 
    }
}

这样我们就能够根据不同的地域生产不同的披萨了。

抽象工厂

• UML:

  
  image.png
• 意义：
  抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体的情况下，创建多个产品族中的产品对象。根据里氏替换原则，任何接受父类型的地方，都应当能够接受子类型。
• 特点：
  抽象工厂模式提供具体工厂角色，分别对应于每个具体产品角色，每一个具体工厂角色只负责某一个产品角色的实例化。每一个具体工厂类只负责创建抽象产品的某一个具体子类的实例。
• 模型：地域披萨店

//抽象工厂
public interface AbsFactory {
    public Pizza CreatePizza(String ordertype) ;
}
public class LDFactory implements AbsFactory {
    @Override
    public Pizza CreatePizza(String ordertype) {
        Pizza pizza = null;
        if (ordertype.equals("cheese")) {
            pizza = new LDCheesePizza();
        } else if (ordertype.equals("pepper")) {
            pizza = new LDPepperPizza();
        }
        return pizza;
    }
}
public class NYFactory implements AbsFactory {
    @Override
    public Pizza CreatePizza(String ordertype) {
        Pizza pizza = null;
        if (ordertype.equals("cheese")) {
            pizza = new NYCheesePizza();
        } else if (ordertype.equals("pepper")) {
            pizza = new NYPepperPizza();
        }
        return pizza;
    }
}
//使用抽象工厂
public class OrderPizza {
    AbsFactory mFactory;
       //注入具体工厂
    public OrderPizza(AbsFactory mFactory) {
        setFactory(mFactory);
    }
    public void setFactory(AbsFactory mFactory) {
        Pizza pizza = null;
        String ordertype;
        this.mFactory = mFactory;
        do {
            ordertype = gettype();
                       //通过工厂生产披萨
            pizza = mFactory.CreatePizza(ordertype);
                      ....
        } while (true);
    }
   .....
}
//测试
public class PizzaStroe {
    public static void main(String[] args) {
        OrderPizza mOrderPizza;
        mOrderPizza=new OrderPizza(new LDFactory());
    }
}

不同地域的披萨组成了多个产品族，我们可以通过不同的工厂生产各个族的产品