设计模式之工厂模式解读

工厂模式的定义：定义一个创建对象的工厂接口，将对象的实际创建工作推迟到具体子工厂类当中。

这满足创建型模式中所要求的“创建与使用相分离”的特点。

按实际业务场景划分，工厂模式有 3 种不同的实现方式，分别是简单工厂模式、工厂方法模式和抽象工厂模式。

简单工厂模式：一个具体的工厂类，可以生成多个不同的产品对象。简单工厂模式不属于23种设计模式。

在简单工厂模式中创建实例的方法通常为静态方法，因此简单工厂模式又叫作静态工厂方法模式。

简单工厂模式的实现：

//产品接口
public interface Tea {
    void show();
}

//红茶
public class RedTea implements Tea{
     @Override
     public void show() {
         System.out.println("制作红茶！！！");
     }
}

//绿茶
public class GreenTea implements Tea{
    @Override
    public void show() {
        System.out.println("制作绿茶！！！");
    }
}

//工厂类
public class SimpleFactory {
    public static Tea makeTea(int type){
        if(type == 1){
            return new RedTea();
        }else if(type ==2){
            return new GreenTea();
        }else{
            System.out.println("制作失败！！！");
            return null;
        }
    }
}

//测试类
public class Test {
    public static void main(String[] args) {
        Tea tea = SimpleFactory.makeTea(1);
        tea.show();
    }
}

简单工厂模式结构图：

简单工厂模式的优点：1、工厂类包含必要的逻辑判断，可以决定在什么时候创建哪一个产品的实例。

2、客户端无需知道所创建具体产品的类名，只需知道参数即可。

3、也可以引入配置文件，在不修改客户端代码的情况下更换和添加新的具体产品类。

简单工厂模式的缺点：1、简单工厂模式的工厂类单一，负责所有产品的创建，职责过重。

2、工厂类代码会非常臃肿，违背高聚合原则。

3、使用简单工厂模式会增加系统中类的个数，增加系统的复杂度和理解难度。

4、系统扩展困难，增加新产品需要修改工厂逻辑，在产品类型较多时，可能造成逻辑过于复杂。

5、简单工厂模式使用了 static 工厂方法，造成工厂角色无法形成基于继承的等级结构。

工厂方法模式：定义一个创建对象的接口，让实现这个接口的类决定创建哪个对象。

工厂方法是对简单工厂的进一步抽象化，可以在不修改原代码的情况下引进新的产品，满足开闭原则。

工厂方法模式的实现：

//产品接口
public interface Tea {
    void make();
}

//红茶
public class RedTea implements Tea{
    @Override
    public void make() {
        System.out.println("制作红茶！！！");
    }
}

//绿茶
public class GreenTea implements Tea{
    @Override
    public void make() {
        System.out.println("制作绿茶！！！");
    }
}

//工厂接口
public interface Factory {
    Tea create();
}

//红茶工厂
public class RedTeaFactory implements Factory{
    @Override
    public Tea create() {
        return new RedTea();
    }
}

//绿茶工厂
public class GreenTeaFactory implements Factory{
    @Override
    public Tea create() {
        return new GreenTea();
    }
}

//测试类
public class FactoryMethodTest {
    public static void main(String[] args) {
        Factory redTeaFactory = new RedTeaFactory();
        Tea redTea = redTeaFactory.create();
        redTea.make();

        Factory greenTeaFactory = new GreenTeaFactory();
        Tea greenTea = greenTeaFactory.create();
        greenTea.make();
    }
}

工厂方法模式结构图：

工厂方法模式的优点：1、用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程。

2、灵活性增强，对于新产品的创建，只需多写一个相应的工厂类。

3、典型的解耦框架。高层模块只需要知道产品的抽象类，无须关心其他实现类。

工厂方法模式的缺点：1、类的个数容易过多，增加复杂度。

2、增加了系统的抽象性和理解难度。

3、抽象产品只能生产一种产品。

抽象工厂模式：为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定对象的具体类就能得到

同一产品族的产品。抽象工厂模式是工厂方法模式的升级版，工厂方法模式只生产一个等级的产品，

而抽象工厂模式可生产多个等级的产品。

产品族：同一个具体工厂所生产的位于不同等级的一组产品称为一个产品族。

产品等级：同一种类型的产品称为一个产品等级。

抽象工厂模式的实现：

//茶接口
public interface Tea {
    void make();
}

//红茶
public class RedTea implements Tea{
    @Override
    public void make() {
        System.out.println("制作红茶！！！");
    }
}

//绿茶
public class GreenTea implements Tea{
    @Override
    public void make() {
        System.out.println("制作绿茶！！！");
    }
}

//奶接口
public interface Milk {
    void make();
}

//牛奶
public class NiuNai implements Milk{
    @Override
    public void make() {
        System.out.println("制作牛奶！！！");
    }
}

//羊奶
public class YangNai implements Milk{
    @Override
    public void make() {
        System.out.println("制作羊奶！！！");
    }
}

//工厂接口
public interface Factory {
    Tea create();

    Milk produce();
}

//工厂1
public class Factory1 implements Factory{
    @Override
    public Tea create() {
        return new RedTea();
    }

    @Override
    public Milk produce() {
        return new NiuNai();
    }
}

//工厂2
public class Factory2 implements Factory{
    @Override
    public Tea create() {
        return new GreenTea();
    }

    @Override
    public Milk produce() {
        return new YangNai();
    }
}

//测试类
public class AbstractFactoryTest {
    public static void main(String[] args) {
        Factory factory = new Factory1();
        Tea tea = factory.create();
        Milk milk = factory.produce();
        tea.make();
        milk.make();
    }
}

抽象工厂模式结构图：

抽象工厂模式的优点：1、用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程。

2、典型的解耦框架。高层模块只需要知道产品的抽象类，无须关心其他实现类。

3、可以在类的内部对产品族中相关联的多等级产品共同管理。

4、当需要产品族时，抽象工厂可以保证客户端只使用一个工厂。

5、增强了程序的可扩展性，当增加新的产品族时，不需要修改原代码，满足开闭原则。

抽象工厂模式的缺点：1、在产品族中需要增加新的产品时，所有的工厂类都需要进行修改。

2、增加了系统的抽象性和理解难度。

设计模式之工厂模式解读

猜你喜欢