设计模式-工厂模式

一、工厂模式的定义

工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，工厂模式主要用来解决开闭原则，尽量减少代码的修改量。

二、工厂模式的实现方法

1.简单工厂模式

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+"cuting");
    }

    public void box(){
        System.out.println(name+"boxing");
    }

    public void setName(String name){
        this.name=name;
    }
}

public class CheesePizza extends pizza {
    @Override
    public void prepare() {
        System.out.println("制作奶酪pizza");
    }che
}

public class GreekPizza extends pizza {

    @Override
    public void prepare() {
        System.out.println("做希腊pizza");
    }
}

如果我们想要得到一种特定的pizza我们可以如下做（没有用工厂模式）

 public pizza prepareTea(String type){
       pizza pizza = null;
        if(type.equals("cheese")){
            pizza = new CheesePizza();
        }else if(type.equals("Greek")){
            pizza = new GreekPizza();
        }
        return tea;
    }

这种方法也能实现但是接下来，我们可以分析下不使用工厂模式的情况：

如果我们的工程中不至一处用了类似这段代码逻辑，那增加一种茶叶的类型（比如毛尖）就需要修改多处代码，不利于维护。

接下来使用简单工厂模式

public class SimpleFactory {
    public pizza createPizza(String type){
        pizza pizza=null;
        if(type.equals("cheese")){
           pizza=new CheesePizza();
        }else  if(type.equals("Greek")){
            pizza=new GreekPizza();
        }
        return pizza;
    }
}

客户端只要如下调用

 public static void main(String[] args) {
        SimpleFactory pizzaFactory = new SimpleFactory();
        pizza cheesePizza= pizzaFactory.createPizza("cheese");
    }

2.抽象工厂模式

简单工厂模式也有一定的局限性，如果你的cheesepizza也有分类比如分为中国的cheesepizza和美国的cheesepizza那么你的逻辑就会变得很臃肿，这也就可以用抽象工厂模式

//定义一个抽象工厂
public interface AbsFactory {
     pizza  creratePizza(String orderType);
}

public class ChinaFactory implements AbsFactory {
    @Override
    public pizza creratePizza(String orderType) {
        pizza pizza=null;
        if(orderType.equals("cheese")){
            pizza=new ChinaChessPizza();
        }else if(orderType.equals("pepper")){
            pizza=new China 	pepperPizza();
        }
        return pizza;
    }
}

public class USAFactory implements AbsFactory{
    @Override
    public pizza creratePizza(String orderType) {
        pizza pizza=null;
        if(orderType.equals("cheese")){
            pizza=new USAChessPizza();
        }else if(orderType.equals("pepper")){
            pizza=new USApepperPizza();
        }
        return pizza;
    }

客户端调用

 public static void main(String[] args) {
        SimpleFactory pizzaFactory = new ChinaFactory();
        pizza cheesePizza= pizzaFactory.createPizza("cheese");
    }

三、设计模式在源码的使用

工厂模式在Calendar这个工具类中有使用

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;
    }

四、个人总结

工厂模式的使用大大降低了代码之间的耦合，是一个很好的设计模式。以上都是个人学习所得如有错误请指出。