工厂模式

先来看个案例

• 定义一个课程标准 ICourse 接口：

public interface ICourse {

    void record();
}

• 创建一个 Java 课程的实现 JavaCourse 类：

public class JavaCourse implements ICourse {
    public void record() {
        System.out.println("录制java课程");
    }
}

• 看客户端调用代码，我们会这样写：

public class Test {
    public static void main(String[] args) {
        ICourse course=new JavaCourse();
        course.record();
    }
}

看上面的代码，父类 ICourse 指向子类 JavaCourse 的引用，应用层代码需要依赖 JavaCourse，如果业务扩展，我继续增加 PythonCourse 甚至更多，那么我们客户端的 依赖会变得越来越臃肿。因此，我们要想办法把这种依赖减弱，把创建细节隐藏。虽然 目前的代码中，我们创建对象的过程并不复杂，但从代码设计角度来讲不易于扩展。

简单工厂模式

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

• 先增加课程 PythonCourse 类：

public class PythonCourse implements ICourse {
    public void record() {
        System.out.println("录制python");
    }
}

• 创建 CourseFactory 工厂类：

 public ICourse creat(String name) {
        //如果增加课程，还得修改代码
        if ("java".equals(name)) {
            return new JavaCourse();
        } else if ("python".equals(name)) {
            return new PythonCourse();
        } else {
            return null;
        }
     }

• 修改客户端调用代码：

        CouseFactory couseFactory = new CouseFactory();
        ICourse java = couseFactory.creat("java");
        java.record();

• 下面来看一下类图：
  
• 客户端调用是简单了，但如果我们业务继续扩展，要增加前端课程，那么工厂中的 create()就要根据产品链的丰富每次都要修改代码逻辑。不符合开闭原则。因此，我们对简单工 厂还可以继续优化，可以采用反射技术：

try {
            if (!(null == name || "".equals(name))) {
                return (ICourse) Class.forName(name).newInstance();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;

• 优化之后，产品不断丰富不需要修改 CourseFactory 中的代码。但是，有个问题是，方法参数是字符串，可控性有待提升，而且还需要强制转型。我们再修改一下代码：

 public ICourse creat2(Class<?> clazz) {
        try {
            if (null != clazz) {
                return (ICourse) clazz.newInstance();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

• 客户端调用：

        CouseFactory couseFactory = new CouseFactory();
        ICourse creat = couseFactory.creat2(JavaCourse.class);
        creat.record();

• 简单工厂模式在 JDK 源码也是无处不在，现在我们来举个例子，例如 Calendar 类，看
  Calendar.getInstance()方法，下面打开的是 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;
    }

• 简单工厂也有它的缺点：工厂类的职责相对过重，不易于扩展过于复杂的产品结构（对象的创建逻辑不同）。

工厂方法模式

• 类的实例在子类，对象实例更加丰富

• 工厂方法模式（Fatory Method Pattern）是指定义一个创建对象的接口，但让实现这个接口的类来决定实例化哪个类，工厂方法让类的实例化推迟到子类中进行。在工厂方法模式中用户只需要关心所需产品对应的工厂，无须关心创建细节，而且加入新的产品符 合开闭原则。

• 工厂方法模式主要解决产品扩展的问题，在简单工厂中，随着产品链的丰富，如果每个课程的创建逻辑有区别的话，工厂的职责会变得越来越多，有点像万能工厂，并不便于维护。根据单一职责原则我们将职能继续拆分，专人干专事。Java 课程由 Java 工厂创建， Python 课程由 Python工厂创建，对工厂本身也做一个抽象

• 先创建 ICourseFactory 接口

public interface ICourseFactory {
    ICourse creat();
}

• 在分别创建子工厂，JavaCourseFactory 类：

public class JacaCourserFactory implements ICourseFactory {
    public ICourse creat() {
        return new JavaCourse();
    }
}

• PythonCourseFactory 类：

public class PythonCourserFactory implements ICourseFactory {

    public ICourse creat() {
        return new PythonCourse();
    }
}

• 看测试代码：

public class Test {
    public static void main(String[] args) {
        ICourseFactory factory = new PythonCourserFactory();
        ICourse creat = factory.creat();
        creat.record();
    }
}

• 现在再来看一下类图：
  

• 工厂方法适用于以下场景：
  1、创建对象需要大量重复的代码。
  2、客户端（应用层）不依赖于产品类实例如何被创建、实现等细节。
  3、一个类通过其子类来指定创建哪个对象。

• 工厂方法也有缺点：
  1、类的个数容易过多，增加复杂度。
  2、增加了系统的抽象性和理解难度。

抽象工厂模式

• 美的工厂可以生产空调，冰箱，洗衣机，海尔工厂也可以生产 空调，冰箱，洗衣机。一个工厂要负责生产一个产品族。

• 抽象工厂模式（Abastract Factory Pattern）是指提供一个创建一系列相关或相互依赖对象的接口，无须指定他们具体的类。客户端（应用层）不依赖于产品类实例如何被创建、实现等细节，强调的是一系列相关的产品对象（属于同一产品族）一起使用创建对象需要大量重复的代码。需要提供一个产品类的库，所有的产品以同样的接口出现，从 而使客户端不依赖于具体实现。

• INote 接口：

public interface INote {
    void note();
}

• 然后创建一个抽象工厂 CourseFactory 类：

public interface ICourseFactory {
    ICourse record();

    INote note();

}

• 接下来，创建 Java 产品族

public class JavaCourse implements ICourse {
    public void record() {
        System.out.println("录制java课程");
    }
}

public class JavaNote implements INote {
    public void note() {
        System.out.println("java笔记");
    }
}

• 创建 Java 产品族的具体工厂 JavaCourseFactory:

public class JavaCourseFactory implements ICourseFactory{
    public ICourse record() {
        return new JavaCourse();
    }

    public INote note() {
        return new JavaNote();
    }
}

• Python产品族也是一样
• 来看客户端调用：

public class Test {
    public static void main(String[] args) {
        ICourseFactory java=new JavaCourseFactory();
        java.record().record();
        java.note().note();
    }
}

上面的代码完整地描述了两个产品族 Java 课程和 Python 课程，也描述了两个产品等级 视频和笔记。

• 但是，不知道大家有 没有发现，如果我们再继续扩展产品等级，将源码 Source 也加入到课程中，那么我们的代码从抽象工厂，到具体工厂要全部调整，很显然不符合开闭原则。因此抽象工厂也是 有缺点的：
  1、规定了所有可能被创建的产品集合，产品族中扩展新的产品困难，需要修改抽象工厂 的接口。
  2、增加了系统的抽象性和理解难度。

代码地址：https://github.com/zhengyao123/mini-gof.git