Java工厂模式

创建一个制作Pizza的例子

传统方式

1.创建一个Pizza的抽象类 所有其他Pizza继承自Pizza

public abstract class Pizza {
    String name;
    //准备原材料
    public abstract void prepare();
    //烘培
    public void bake(){
        System.out.println(name+"bake");
    }
    //切块
    public void cut(){
        System.out.println(name+"cut");
    }
    public void setName(String name){
        this.name=name;
    }
}
public class GreekPizza extends Pizza {
    @Override
    public void prepare() {
        System.out.println("GreekPizza prepare");
    }
}
public class CheesePizza extends Pizza {
    @Override
    public void prepare() {
        System.out.println("CheesePizza prepare");
    }
}

2.订购PIzza

public class OrderPizza {
    public OrderPizza(){
        Pizza pizza=null;
        String orderType; //订购披萨的类型
        Scanner s=new Scanner(System.in);
        //订购披萨
        do{
            System.out.println("输入披萨种类：");
            orderType=s.next();
            if(orderType.equals("greek")){
                pizza=new GreekPizza();
                pizza.setName("greek");
            }else if(orderType.equals("cheese")){
                pizza=new CheesePizza();
                pizza.setName("cheese");
            }else{
                break;
            }
            pizza.prepare();
            pizza.bake();
            pizza.cut();
        }while (true);
    }

}

此方式的优缺点
优点：简单易操作
缺点：违反了OCP原则（对扩展开放，对修改关闭），即当我们给类增加新功能时，尽量不修改代码，或者尽可能少修改代码

按以上的传统方式，当我们需要新增Pizza时，首先需要新增一个Pizza的子类 然后在OrderPizza中修改代码

改进思路：把创建Pizza对象封装到类中，这样又新的Pizza种类时，只需要修改该类，其他又创建到Pizza对象的代码就不需要修改了–》简单工厂模式

简单工厂

简单工厂模式是属于创建型模式 是工厂模式的一种 简单工厂模式是由一个工厂对象决定船舰出哪一种产品的实例
简单工厂模式：定义一个创建对象的类，由这个类来封装实例化对象的行为
Pizza类及其子类和上面的传统模式相同：

订购Pizza：

public class OrderPizza {
   PizzaSimpleFactory pizzaSimpleFactory;
   Pizza pizza=null;
   public OrderPizza(PizzaSimpleFactory s){
       this.setFactory(s);
   }
   public void setFactory(PizzaSimpleFactory s){
       String orderType="";
       Scanner sc=new Scanner(System.in);
       this.pizzaSimpleFactory=s;
       do{
           System.out.println("输入pizza类型");
           orderType=sc.next();
           pizza=pizzaSimpleFactory.createPizza(orderType);
           if(pizza!=null){
               pizza.prepare();
               pizza.bake();
               pizza.cut();
           }
       }while (true);

   }

}

Pizza简单工厂：

public class PizzaSimpleFactory {
    //根据orderType返回对应的Pizza对象
    public Pizza createPizza(String orderType){
        Pizza pizza=null;
        System.out.println("Using SimpleFactory");
        if(orderType.equals("greek")){
            pizza=new GreekPizza();
            pizza.setName("greek");
        }else if(orderType.equals("cheese")){
            pizza=new CheesePizza();
            pizza.setName("cheese");
        }
       return pizza;
    }
}

当后序修改代码时，只需要修改Factory里即可，不再需要修改OrderPizza。因为OrderPizza可能是有多个的，而Factory只有一个，如果修改OrderPizza会很复杂。Factory相当于Pizza和OrderPizza的中间层，来降低Pizza和OrderPizza的耦合

新需求：点Pizza时可以选择不同口味的Pizza 比如北京的GreekPizza 纽约的GreekPizza
使用工厂方法模式

工厂方法模式

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

此处的OrderPizza就是一个工厂类

Pizza及其子类：

public abstract class Pizza {
    String name;
    //准备原材料
    public abstract void prepare();
    //烘培
    public void bake(){
        System.out.println(name+"bake");
    }
    //切块
    public void cut(){
        System.out.println(name+"cut");
    }
    public void setName(String name){
        this.name=name;
    }
}
public class BJCheesePizza extends Pizza {
    @Override
    public void prepare() {
        setName("北京奶酪披萨");
        System.out.println("BJCheesePizza prepare");
    }
}
public class BJGreekPizza extends Pizza {
    @Override
    public void prepare() {
        setName("北京GreekPiza");
        System.out.println("BJGreekPizza prepare");
    }
}
public class LDCheesePizza extends Pizza {
    @Override
    public void prepare() {
        setName("伦敦CheesePiza");
        System.out.println("LDCheesePizza prepare");
    }
}
public class LDGreekPizza extends Pizza {
    @Override
    public void prepare() {
        setName("LDGreekPiza");
        System.out.println("LDGreekPizza prepare");
    }
}

OrderPizza及其子类：

public abstract class OrderPizza {


  abstract Pizza createPizza(String orderType);
  public OrderPizza(){
      Pizza pizza=null;
      String orderType;
      Scanner sc=new Scanner(System.in);
      do{
          orderType=sc.next();
          pizza=createPizza(orderType); //抽象方法 由工厂子类完成
          pizza.prepare();
          pizza.bake();
          pizza.cut();
      }while (true);
  }
}
public class BJOrderPizza extends OrderPizza {
    @Override
    Pizza createPizza(String orderType) {
        Pizza pizza=null;
        if(orderType.equals("cheese")){
            pizza=new BJCheesePizza();
        }else if(orderType.equals("greek")){
            pizza=new BJGreekPizza();
        }
        return pizza;
    }
}
public class LDOrderPizza {
    Pizza pizza=null;
    Pizza createPizza(String orderType){
        if(orderType.equals("greek")){
            pizza= new LDGreekPizza();
        }else if(orderType.equals("cheese")){
            pizza= new LDCheesePizza();
        }
        return pizza;
    }
}

PizzaStore：

//相当于客户端 完成Pizza订购
public class PizzaStore {
    public static void main(String[] args) {
        BJOrderPizza bjOrderPizza=new BJOrderPizza();
    }
}

抽象工厂模式

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

Pizza及其子类与工厂方法模式相同

AbsFactory及其子类：

public interface AbsFactory {
    public Pizza createPizza(String orderType);
}
public class BJFactory implements AbsFactory {
    @Override
    public Pizza createPizza(String orderType) {
        Pizza pizza=null;
        if(orderType.equals("cheese")){
            pizza=new BJCheesePizza();
        }else if(orderType.equals("greek")){
            pizza=new BJGreekPizza();
        }
        return pizza;
    }
}
public class LDFactory implements AbsFactory {
    @Override
    public Pizza createPizza(String orderType) {
       Pizza pizza=null;
        if(orderType.equals("greek")){
           pizza=new LDGreekPizza();
       }else if(orderType.equals("cheese")){
            pizza=new LDCheesePizza();
        }
        return pizza;
    }
}

OrderPizza：

public class OrderPizza {
    AbsFactory absFactory;
    public void setFactory(AbsFactory abs){
        this.absFactory=abs;
        Scanner sc=new Scanner(System.in);
        do{
            String orderType = sc.next();
            Pizza pizza = absFactory.createPizza(orderType);
            pizza.prepare();
            pizza.bake();
            pizza.cut();
        }while(true);
    }
    public OrderPizza(AbsFactory abs){
        setFactory(abs);
    }

}

工厂模式在JDK中的使用

Calender中使用了工厂模式

 private static Calendar createCalendar(TimeZone zone,
                                           Locale aLocale)
    {
        CalendarProvider provider =
            LocaleProviderAdapter.getAdapter(CalendarProvider.class, aLocale)
                                 .getCalendarProvider();
        if (provider != null) {
            try {
                return provider.getInstance(zone, aLocale);
            } catch (IllegalArgumentException iae) {
                // fall back to the default instantiation
            }
        }

        Calendar cal = null;

        if (aLocale.hasExtensions()) {
            String caltype = aLocale.getUnicodeLocaleType("ca");
            if (caltype != null) {
                switch (caltype) {
                case "buddhist":
                cal = new BuddhistCalendar(zone, aLocale);
                    break;
                case "japanese":
                    cal = new JapaneseImperialCalendar(zone, aLocale);
                    break;
                case "gregory":
                    cal = new GregorianCalendar(zone, aLocale);
                    break;
                }
            }
        }
        if (cal == null) {
            // If no known calendar type is explicitly specified,
            // perform the traditional way to create a Calendar:
            // create a BuddhistCalendar for th_TH locale,
            // a JapaneseImperialCalendar for ja_JP_JP locale, or
            // a GregorianCalendar for any other locales.
            // NOTE: The language, country and variant strings are interned.
            if (aLocale.getLanguage() == "th" && aLocale.getCountry() == "TH") {
                cal = new BuddhistCalendar(zone, aLocale);
            } else if (aLocale.getVariant() == "JP" && aLocale.getLanguage() == "ja"
                       && aLocale.getCountry() == "JP") {
                cal = new JapaneseImperialCalendar(zone, aLocale);
            } else {
                cal = new GregorianCalendar(zone, aLocale);
            }
        }
        return cal;
    }

Calender的创建是通过Calender.getInstance()来获得实例对象
getInstance就是调用上面的createCalendar方法

    public static Calendar getInstance()
    {
        return createCalendar(TimeZone.getDefault(), Locale.getDefault(Locale.Category.FORMAT));
    }

如上的createCalendar（）中
通过一个switch来判断时区从而创建不同的对象，是一种简单工厂模式

小结

工厂模式的意义：
将实例化对象的代码提取出来，放到一个类中统一管理和维护，达到和主项目的依赖关系的解耦，从而提高项目的扩展和维护性。
设计模式的依赖抽象原则：
创建对象实例时，不要直接new类，而是把这个new类的动作放在一个工厂的方法中，并返回
不要让类继承具体类，而是继承抽象类或者实现interface
不要覆盖基类中已经实现的方法