常见的设计模式之工厂模式

概念

工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

简单工厂模式

简单工厂模式（Simple Factory Pattern）是指由一个工厂对象决定创造出哪一种产品的实例类，但它不属于GOF23种设计模式。

1.创建接口

public interface ICourse {
    public void record();
}

2.创建接口实现类

public class JavaCourse implements ICourse{
    @Override
    public void record() {
        System.out.println("Java 语言");
    }
}

public class PythonCourse implements ICourse {
    @Override
    public void record() {
        System.out.println("pythod语言");
    }
}

3.创建工厂类

public class SimpleFactory {
    public ICourse getCourse(String name){
        if("java".equals(name)){
            return new JavaCourse();
        }
        if("python".equals(name)){
            return new PythonCourse();
        }else{
            return null;
        }
    }
}

4.创建测试类

public class FactoryTest {
    public static void main(String[] args) {
        SimpleFactory simpleFactory = new SimpleFactory();
        ICourse course = simpleFactory.getCourse("java");
        course.record();
    }
}

运行结果：

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

缺点

• 工厂类的职责相对过重，不易于扩展过于复杂的产品结构

工厂方法模式

工厂方法模式（Factory Method Pattern）是指定义一个创建对象的接口，但让实现这个接口的类来决定实例化哪个类，工厂方法让类的实例化推迟到子类中进行。

1.创建工厂接口

public interface ICourseFactory {
    public ICourse create();
}

2.创建实现接口的工厂类

public class JavaCourseFactory implements ICourseFactory{
    @Override
    public ICourse create() {
        return new JavaCourse();
    }
}

public class PythonCourseFactory implements ICourseFactory{
    @Override
    public ICourse create() {
        return new PythonCourse();
    }
}

3.测试类

public class FactoryMethodTest {
    public static void main(String[] args) {
        ICourseFactory iCourseFactory=new JavaCourseFactory();
        ICourse icourse=iCourseFactory.create();
        icourse.record();
    }
}

运行结果：

在工厂方法模式中用户只需要关心所需产品对应的工厂，无需关心创建细节

缺点

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

抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

1.创建产品接口

public interface IAirConditioning {
    public void cold();
}

public interface IPhone {
    public void call();
}

2.创建产品

public class GreePhone implements IPhone {
    @Override
    public void call() {
        System.out.println("格力电话");
    }
}

public class GreeAirConditioning implements IAirConditioning {
    @Override
    public void cold() {
        System.out.println("好空调，格力造");
    }
}

public class MideaPhone implements IPhone{
    @Override
    public void call() {
        System.out.println("美的电话");
    }
}

public class MideaAirConditioning implements IAirConditioning {
    @Override
    public void cold() {
        System.out.println("美的空调-精彩生活由我创造");
    }
}

3.创建抽象工厂

public abstract class  AbstractFactory {
    public void init(){
        System.out.println("开始。。。");
    }
    protected abstract  IPhone createPhone();
    protected abstract  IAirConditioning createAirConditioning();
}

4.创建具体工厂

public class MideaFactory extends AbstractFactory{
    @Override
    protected IPhone createPhone() {
        return new MideaPhone();
    }

    @Override
    protected IAirConditioning createAirConditioning() {
        return new MideaAirConditioning();
    }
}

public class GreeFactory extends AbstractFactory {
    @Override
    protected IPhone createPhone() {
        return new GreePhone();
    }

    @Override
    protected IAirConditioning createAirConditioning() {
        return new GreeAirConditioning();
    }
}

4.测试

public class AbstractFactoryTest {
    public static void main(String[] args) {
        GreeFactory greeFactory=new GreeFactory();
        greeFactory.createAirConditioning().cold();
    }
}

运行结果：

缺点

• 规定了所有可能被创建的产品集合，产品族如果发生改变，那么从抽象工厂到具体工厂都要发生调整，不符合开闭原则
• 增加了系统的抽象性和理解难度

开闭原则：一个软件实体如类，模块和函数应该对扩展开放，对修改关闭。