工厂模式

简单工厂模式
需求：
看一个披萨的项目：要便于披萨种类的扩展，要便于维护
1) 披萨的种类很多(比如 GreekPizz、CheesePizz 等)
2) 披萨的制作有 prepare，bake, cut, box
3) 完成披萨店订购功能。

订购 Pizza
class Pizza {

}
优缺点分析 ：
1、优点：比较好理解，简单易操作
2、缺点：违反了设计模式的 ocp原则（对扩展开放，对修改关闭）。即：当我们给类增加新功能的时候，尽量不修改代码，或者少修改代码。
3、如果新增一个 Pizza 种类，则订购 Pizza 的代码都要修改。
4、改进的思路分析：
分析：如果在多处 都有创建 Pizza 实例的代码，要修改多处。
思路：如果把创建 Pizza 对象 封装到一个 类种，这样的话，增加新的 Pizza 种类时，只需要修改该类 即可。其它有创建 Pizza 对象的代码 就不需要修改了。------》简单工厂模式

 

简单工厂模式 （静态工厂模式）
基本介绍：
1、简单工厂模式是属于创建型模式，是工厂模式的一种。 简单工厂模式是由一
个工厂对象决定创建出哪一 种产品类 的实例。简单工厂模式是工厂模式家族中最简单实用的模式
2、简单工厂模式：定义了一个创建对象的类，由这个类来 封装实例化对象的行为 (代码)
3、在软件开发中，当我们会用到大量的创建某种、某类或者某批对象时，就会使用到工厂模式.

例子：
设计方案：定义一个可以实例化 Pizza 对象的类，封装创建对象的代码。

简单工厂类 ：

// 编写简单工厂类
public class SimpleFactory {
    public Pizza createPizza(String type) {
        System.out.println(" 使用简单工厂模式 ~~");
        Pizza pizza = null;
        if (type.equals("cheese")) {
            pizza = new CheesePizza();
            pizza.setName("奶酪pizza");
         } else if (type.equals("greek")) {
            pizza = new GreekPizza();
            pizza.setName("希腊pizza");
        } else if (type.equals("pepper")) {
            pizza = new PepperPizza();
            pizza.setName("胡椒pizza");
        }
        return pizza;
    }
}

//订购 Pizza 的类
 public class OrderPizza {
     //1、定义一个简单工厂对象
     SimpleFactory simpleFactory;
     Pizza pizza;
     //构造器
     public OrderPizza(SimpleFactory simpleFactory){
         setFactory(simpleFactory);
     }
     
     public void setFactory(SimpleFactory simpleFactory){
         String orderType = "";//用户需要的 种类
         this.simpleFactory = simpleFactory ;//这只简单工厂对象
         
         do{
             orderType = getType();
             pizza = this.simpleFactory.createPizza(orderType);
             //输出 pizza 
             if(pizza !=null){//订购成功
                 pizza.prepare();
                 pizza.bake();
                 pizza.cut();
                 pizza.box();
             }else{
                 System.out.println("订购Pizza失败");
                 break;
             }
         }while(true);
         
     }
    
}   

　　

工厂方法模式
新需求：客户在点 披萨时，点不同口味的 Pizza ，比如 北京的奶酪披萨、北京的芝士披萨、洛杉矶的胡椒披萨
思路1：使用 简单工厂模式，创建不同的简单工厂类，比如 BJPizzaSimpleFactory 、LSJPizzaSimpleFactory 等等。这种方法满足了当前的需求，但考虑到项目的规模，软件的可维护性、可扩展性 并不好。
思路2：工厂方法模式

工厂方法模式介绍
1、工厂方法模式设计方案：将披萨项目的实例化功能抽象成抽象方法，在不同的口味点
餐子类中具体实现。
2、工厂方法模式：定义了一个创建对象的抽象方法，由子类决定要实例化的类。工厂方
法模式将对象的实例化推迟到子类。

应用案例
1、披萨项目新的需求：客户在点披萨时，可以点不同口味的披萨，比如 北京的奶酪
pizza、北京的胡椒pizza 或者是伦敦的奶酪pizza、伦敦的胡椒pizza
2、思路分析图解

代码：

//定制披萨抽象类
public abstract class OrderPizza {
    public OrderPizza() {
        Pizza pizza = null;
        String ordertype;//订购披萨的类型
        do {
            ordertype = gettype();
            pizza = createPizza(ordertype);//抽象方法,由工厂子类完成
            if (pizza != null) {
                pizza.prepare();
               pizza.bake();
               pizza.cut();
               pizza.box();
            } else {
               break;
            }
        } while (true);
    }
    //定义一个抽象方法,createPizza（）让各个工厂子类自己实现
    abstract Pizza createPizza(String ordertype);
    //获取用户输入的 东西
    private String getType(){
        try{
            BufferedReader strin=new BufferedReader(new InputStreamReader(System.in))；
            System.out.println(“input pizza种类：”)；
            String str=strin.readLine()；
            return str；
        }catch(IOException E){
            e.printStackTrace();
            return ""；
        }
    }
}
//
public class BJOrderPizza extends OrderPizza {
    @Override
    Pizza createPizza(String type) {
        Pizza pizza = null;
        if (type.equals("cheese")) {
            pizza = new BJCheesePizza();
        } else if (type.equals("pepper")) {
            pizza = new BJPepperPizza();
        }
        return pizza;
    }
}

　　

抽象工厂模式

1、基本介绍
1）、定义了一个interface用于创建相关或有依赖关系的对象簇，而无需指明具体的类
2）、抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合
3）、从设计层面看，抽象工厂模式就是对简单工厂模式的改进(或者称为进一步的抽象)。
4）、将工厂抽象成两层，AbsFactory(抽象工厂) 和 具体实现的工厂子类。程序员可以根据创建对象类型使用对应的工厂子类。这样将单个的简单工厂类变成了工厂簇，更利于代码的维护和扩展。
5）、类图如下

代码：

//一个挺象工模模式的抽象层(接口)
public interface AbsFactory{
    //让下面的工厂子类来 具体实现
    public Pizza createPizza(String type);
}

public class BJFactory implements AbsFactory {
    @Override
    public Pizza createPizza(String type) {
        Pizza pizza = null;
        if (type.equals("cheese")) {
            pizza = new BJCheesePizza();
        } else if (type.equals("pepper")) {
            pizza = new BJPepperPizza();
        }
        return pizza;
    }
}

public class OrderPizza{
    AbsFactory absFactory;
    
    //构造器
    public OrderPizza(AbsFactory absFactory){
        setFactory(absFactory);
    }
    
    private void setFactory(AbsFactory absFactory){
        Pizza pizza = null;
        String ordertype = "";//订购披萨的类型
        this.absFactory = absFactory;
        do {
            ordertype = gettype();
            //absFactory 可能是北京的工厂子类,也可能是伦敦的工厂子类
            pizza = absFactory.createPizza(ordertype);//抽象方法,由工厂子类完成
            if (pizza != null) {
               pizza.prepare();
               pizza.bake();
               pizza.cut();
               pizza.box();
            } else {
               break;
            }
        } while (true);
    }
}

　　

工厂模式小结
1) 工厂模式的意义
将实例化对象的代码提取出来，放到一个类中统一管理和维护，达到和主项目的依赖关系的解耦。从而提高项目的扩展和维护性。
2) 三种工厂模式 (简单工厂模式、工厂方法模式、抽象工厂模式)
3) 设计模式的依赖抽象原则
 创建对象实例时，不要直接 new 类, 而是把这个new 类的动作放在一个工厂的方法中，并返回。有的书上说，变量不要直接持有具体类的引用。
 不要让类继承具体类，而是继承抽象类或者是实现interface(接口)
 不要覆盖基类中已经实现的方法。

 

简单工厂、工厂方法、抽象工厂三种模式总是不能正确区分，以下是自己浅薄的理解。并附上一个还不错的详解博客

简单工厂：一个工厂一条产品线生产所有产品，如果想要新的产品，则要修改产品线。
工厂方法：一个工厂，多条产品线。如果想要新产品，则增加产品线
抽象工厂：一个工厂，多条产品线，每条产品线可以生成多个不同种类的产品

简单工厂模式&工厂方法模式&抽象工厂模式的区别：

https://www.cnblogs.com/sunweiye/p/10815928.html