结合JDK源码看设计模式——简单工厂、工厂方法、抽象工厂

三种工厂模式的详解：

简单工厂模式：

　　适用场景：工厂类负责创建的对象较少，客户端只关心传入工厂类的参数，对于如何创建对象的逻辑不关心

　　缺点：如果要新加产品，就需要修改工厂类的判断逻辑，违背软件设计中的开闭原则，且产品类多的话，就会使得简单工厂类比较复杂

　　在jdk源码中的具体实例（注意看代码中的中文注释）

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

　　除了日历类还有jdbc，当我们需要mysql数据库的驱动时，我们就传mysql的参数，用oracle的就传相应的参数

 

工厂方法模式：

 

　　适用场景：创建对象需要大量重复代码，客户端不依赖与产品类实例如何被创建实现等细节，一个类通过其子类来指定创建哪个对象

　　工厂方法的核心在于把实例化过程放在子类中进行（这是和简单工厂一个区别比较大的地方）

　　要解释工厂方法模式，要有下面的概念：一个总的抽象工厂及抽象工厂的子类还有一个抽象的产品类与抽象产品类的子类，具体看下面的jdk源码：

拿其中arraylist实现的iterator()方法来看

public iterator<e> iterator() {
        return new itr();
    }
 
    /**
     * an optimized version of abstractlist.itr
     */
    private class itr implements iterator<e> {
        int cursor;       // index of next element to return
        int lastret = -1; // index of last element returned; -1 if no such
        int expectedmodcount = modcount;
 
        public boolean hasnext() {
            return cursor != size;
        }
 
        @suppresswarnings("unchecked")
        public e next() {
            checkforcomodification();
            int i = cursor;
            if (i >= size)
                throw new nosuchelementexception();
            object[] elementdata = arraylist.this.elementdata;
            if (i >= elementdata.length)
                throw new concurrentmodificationexception();
            cursor = i + 1;
            return (e) elementdata[lastret = i];
        }

　　可以这样理解：collection接口里面定义了许多方法就像size(),isempty(),iterator()等等这些方法可以认为是工厂里面的产品，collection可以看作是一个总的抽象工厂。它的一些实现这个接口的类，像arraylist，linkedhashset等等可以看作一个个不同的品牌的工厂，而总的产品iterator接口里面会定义产品所需功能的细节，然后在交给各个品牌不同的工厂来实现。

抽象工厂模式：

　　看懂上面的之后就特别好理解抽象工厂，抽象工厂模式与工厂方法模式的最大区别就在于，工厂方法模式针对的是一个产品等级结构；（比如iterator()方法的不同实现）而抽象工厂模式则需要面对多个产品等级结构（collection接口下的不同方法）。再说明白一点就是：collection就是一个抽象工厂，它提供了一个产品类的库，所有产品都以同样接口出现，从而使客户端不依赖于具体实现。工厂方法则是抽象工厂里面的其中一个产品类，并且把这个方法的实例化放入具体的实现类中