JAVA架构师之路二：设计模式之工厂模式

JAVA架构师之路一：七大软件设计原则

世界上本没有路，走的人多了，也便成了路。——鲁迅

不用设计模式可以不可以？答案是可以。但是用好设计模式能帮助我们更好地解决实际问题，设计模式最重要的是解耦。学习设计模式，主要是总结经验的，把经验为自己所用，同时也是锻炼将业务需求转换技术实现的一种非常有效的方式。

1. 工厂模式的历史由来

2. 简单工厂

定义

简单工厂模式是指一个工厂对象决定创建那种产品类的实例。
属于创建型模式，但是不属于GOF 23种设计模式。

适用场景

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

优点

只需传入一个正确的参数就能获取你需要的对象，无须知道具体的细节

缺点

工厂类的职责相对过重，增加新的产品时需要修改工厂类的判断逻辑，违背开闭原则。
不易于扩展过于复杂的产品结构。

代码

public interface ICouse {

    void record();
}

public class JavaCouse implements ICouse {
    @Override
    public void record() {
        System.out.println("Java课程");
    }
}

public class PythonCouse implements ICouse {
    @Override
    public void record() {
        System.out.println("Python课程");
    }
}

public class CouseFactory {

    /**
     * 版本1
     * @param name
     * @return
     */
    public ICouse create1(String name) {
        if ("java".equals(name)) {
            return new JavaCouse();
        } else if ("python".equals(name)) {
            return new PythonCouse();
        } else {
            return null;
        }
    }

    /**
     * 版本2
     * @param className
     * @return
     */
    public ICouse create2(String className) {
        if (!(null == className || "".equals(className))) {
            try {
                return (ICouse) Class.forName(className).newInstance();
            } catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    public ICouse create3(Class<? extends ICouse> clazz) {
        if (null != clazz) {
            try {
                return clazz.newInstance();
            } catch (InstantiationException | IllegalAccessException e) {
                e.printStackTrace();
            }
        }
        return null;
    }
}

public class Test {

    public static void main(String[] args) {
        ICouse couse1 = new CouseFactory().create1("java");
        couse1.record();
        ICouse couse2 = new CouseFactory().create2("com.test.factory.JavaCouse");
        couse2.record();
        ICouse couse3 = new CouseFactory().create3(JavaCouse.class);
        couse3.record();
    }
}

类图

JDK工厂模式简单应用
Calendar.java 的 getInstance()方法的初始化用到的简单工厂模式。根据不同的Local时区，创建不同的Calendar对象。

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

3. 工厂方法模式

定义

定义一个创建对象的接口，但让实现这个接口的类来决定实例化哪个类，工厂方法让类的实例化推迟到子类中进行。
属于创建型设计模式。

适用场景

创建对象需要大量的重复代码。
客户端(应用层)不依赖于产品类实例如何被创建、实现等细节。
一个类通过其子类来指定创建哪个对象。

优点

用户只需要关心所需产品对应的工厂，无需关键创建细节。
加入新产品符合开闭原则，提高系统的可扩展性。

缺点

类的个数容易过多，增加了代码结构的复杂度。
增加了系统的抽象性和理解难度。

代码

public interface ICouseFactory {

    ICouse create();
}

public class JavaCouseFactory implements ICouseFactory {
    @Override
    public ICouse create() {
        return new JavaCouse();
    }
}

public class PythonCouseFactory implements ICouseFactory {
    @Override
    public ICouse create() {
        return new PythonCouse();
    }
}

public class Test1 {

    public static void main(String[] args) {
        ICouseFactory couseFactory1 = new JavaCouseFactory();
        ICouse couse1 = couseFactory1.create();
        couse1.record();

        ICouseFactory couseFactory2 = new PythonCouseFactory();
        ICouse couse2 = couseFactory2.create();
        couse2.record();
    }
}

类图

4. 抽象工厂模式

定义

是指提供一个创建一系列相关或相互依赖对象的接口，无需指定他们具体的类。
属于创建型设计模式。

适用场景

客户端(应用层)不依赖于产品类实例如何被创建、实现等细节
强调一系列相关的产品对象(属于同一产品族)一起使用创建对象需要大量复用的代码。
提供一个产品类库，所有的产品以同样的接口形式出现，从而使客户端不依赖于具体实现。

优点

具体产品在应用层代码隔离，无须关心创建细节
将一个系列的产品族统一到一起创建

缺点

规定了所有可能被创建的产品集合，产品族中扩展新的产品
困难，需要修改抽象工厂的接口
增加了抽象工厂的抽象性和理解难度

代码

public abstract class CouseFactory {

    public void init() {
        System.out.println("初始化基础数据");
    }

    protected abstract INote createNote();

    protected abstract IVideo createVideo();
}

public class JavaCouseFactory extends CouseFactory {
    @Override
    protected INote createNote() {
        super.init();
        return new JavaNote();
    }

    @Override
    protected IVideo createVideo() {
        super.init();
        return new JavaVideo();
    }
}

public class PythonCouseFactory extends CouseFactory {
    @Override
    protected INote createNote() {
        super.init();
        return new PythonNote();
    }

    @Override
    protected IVideo createVideo() {
        super.init();
        return new PythonVideo();
    }
}

public interface INote {

    void edit();
}

public interface IVideo {

    void record();
}

public class JavaNote implements INote {
    @Override
    public void edit() {
        System.out.println("java note");
    }
}

public class JavaVideo implements IVideo {
    @Override
    public void record() {
        System.out.println("java video");
    }
}

public class PythonNote implements INote {
    @Override
    public void edit() {
        System.out.println("python note");
    }
}

public class PythonVideo implements IVideo {
    @Override
    public void record() {
        System.out.println("python video");
    }
}

public class Test {
    public static void main(String[] args) {
        CouseFactory couseFactory1 = new JavaCouseFactory();
        couseFactory1.createNote().edit();
        couseFactory1.createVideo().record();

        CouseFactory couseFactory2 = new PythonCouseFactory();
        couseFactory2.createNote().edit();
        couseFactory2.createVideo().record();
    }
}

类图


感谢您阅读本文，如果您觉得文章写的对您有用的话，请您点击上面的“关注”，点个赞，这样您就可以持续收到《JAVA架构师之路》的最新文章了。文章内容属于自己的一点点心得，难免有不对的地方，欢迎在下方评论区探讨，你们的关注是我创作优质文章的动力。

JAVA架构师之路三：设计模式之单例模式