设计模式学习笔记（5）——工厂模式

版权声明：本文为博主原创，未经博主允许不得转载。 https://blog.csdn.net/weixin_36904568/article/details/89892715

工厂模式：通过工厂，封装创建对象的代码，不需要具体实例化，使用工厂实例化

一：简单工厂

1. 定义

又叫做静态工厂方法模式。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。

2. 使用

一个静态方法通过参数，创建需要的对象

• 抽象产品类
• 具体产品类
• 静态工厂类
• 业务类
  • 具体业务方法：使用静态工厂生产的产品

（1）产品

package FactoryPattern.SimpleFactoryPattern;

/**
 * 抽象产品
 */
public interface Product {
    public void operate();
}

package FactoryPattern.SimpleFactoryPattern;

/**
 * 具体产品A
 */
public class ProductA implements Product{
    @Override
    public void operate() {
        System.out.println("产品A的业务逻辑");
    }
}

package FactoryPattern.SimpleFactoryPattern;

/**
 * 具体产品B
 */
public class ProductB implements Product{
    @Override
    public void operate() {
        System.out.println("产品B的业务逻辑");
    }
}

（2）静态工厂

package FactoryPattern.SimpleFactoryPattern;

/**
 * 静态工厂
 */
public class Factory {
    public static Product createProduct(String type){
        switch (type) {
            case "A":
                return new ProductA();
            case "B":
                return new ProductB();
            default:
                throw new RuntimeException("not found this type!");
        }
    }
}

（3）测试

package FactoryPattern.SimpleFactoryPattern;

public class Test {
    public static void main(String[] args) {
        Product product = Factory.createProduct("A");
        product.operate();
        product = Factory.createProduct("B");
        product.operate();
        product = Factory.createProduct("C");
        product.operate();
    }
}

3. 特点

• 当系统引入新的产品的时候无需修改业务方法
• 工厂类集中了所有的创建逻辑，过于臃肿
• 无法变更正在创建的对象

二：工厂方法

定义

又叫做虚拟构造子模式或者多态性工厂模式。通过定义创建对象的接口，由子类动态决定实例化，将实际创建工作推迟到子类中。

使用

抽象工厂方法（类的继承）

• 抽象工厂类
  • 抽象工厂方法：单一产品
• 具体工厂类
  • 具体工厂方法：创建具体产品
• 抽象产品类
• 具体产品类
• 业务类
  • 具体业务方法：使用抽象工厂类生产的抽象产品

（1）工厂

package FactoryPattern.FactoryFunctionPattern;

/**
 * 抽象工厂
 */
public abstract class Factory {

    public abstract Product createProduct(String type);

}

package FactoryPattern.FactoryFunctionPattern;

/**
 * 具体工厂A——产生A风格的具体产品
 */
public class FactoryA extends Factory {
    @Override
    public Product createProduct(String type) {
        if (type.equals("1"))
            return new ProductA_1();
        else if (type.equals("2"))
            return new ProductA_2();
        else
            throw new RuntimeException("not found this type!");
    }
}

package FactoryPattern.FactoryFunctionPattern;

/**
 * 具体工厂B——产生B风格的具体产品

 */
public class FactoryB extends Factory {
    @Override
    public Product createProduct(String type) {
        if (type.equals("1"))
            return new ProductB_1();
        if (type.equals("2"))
            return new ProductB_2();
        else
            throw new RuntimeException("not found this type!");
    }
}

（2）产品

package FactoryPattern.FactoryFunctionPattern;

/**
 * 抽象产品
 */
public interface Product {
    public void operate();
}

package FactoryPattern.FactoryFunctionPattern;

/**
 * 具体产品A
 */
public class ProductA_1 implements Product {
    @Override
    public void operate() {
        System.out.println("产品A_1的业务逻辑");
    }
}

package FactoryPattern.FactoryFunctionPattern;

/**
 * 具体产品A
 */
public class ProductA_2 implements Product {
    @Override
    public void operate() {
        System.out.println("产品A_2的业务逻辑");
    }
}

package FactoryPattern.FactoryFunctionPattern;

/**
 * 具体产品B
 */
public class ProductB_1 implements Product {
    @Override
    public void operate() {
        System.out.println("产品B_1的业务逻辑");
    }
}

package FactoryPattern.FactoryFunctionPattern;

/**
 * 具体产品B
 */
public class ProductB_2 implements Product {
    @Override
    public void operate() {
        System.out.println("产品B_2的业务逻辑");
    }
}

（3）测试

package FactoryPattern.FactoryFunctionPattern;

public class Test {
    public static void main(String[] args) {
        //使用产品A1的业务
        Factory factory = new FactoryA();
        Product product = factory.createProduct("1");
        product.operate();
        //使用产品B2的业务
        factory = new FactoryB();
        product = factory.createProduct("2");
        product.operate();

    }
}

3. 特点

• 增加新的产品类型时，系统完全支持“开-闭原则”
• 允许系统在不修改具体工厂的情况下引进新的产品

三：抽象工厂

1. 定义

抽象工厂模式：提供一个接口，用于创建相关或依赖对象的产品族，不需要明确具体工厂类

• 产品族：由位于不同产品等级结构中，功能相关联的产品组成的家族
• 产品等级结构：由相同的结构的产品组成

2. 使用

• 抽象工厂接口：相关联的产品组合
  • 多个抽象工厂方法：多个产品
• 具体工厂
  • 多个实现工厂方法
• 抽象产品类
• 具体产品类
• 业务类
  • 具体业务方法：使用抽象工厂接口生产的抽象产品

（1）工厂

package FactoryPattern.AbstractFactoryPattern;

/**
 * 抽象工厂
 */
public interface Factory {

    //产品结构A的产品
    public ProductA createProductA();

    //产品结构B的产品
    public ProductB createProductB();
}

package FactoryPattern.AbstractFactoryPattern;
/**
 * 具体工厂——实现产品族1
 */
public class Factory1 implements Factory {
    @Override
    public ProductA createProductA() {
        return new ProductA_1();
    }

    @Override
    public ProductB createProductB() {
        return new ProductB_1();
    }
}

package FactoryPattern.AbstractFactoryPattern;

/**
 * 具体工厂——实现产品族2
 */
public class Factory2 implements Factory {
    @Override
    public ProductA createProductA() {
        return new ProductA_2();
    }

    @Override
    public ProductB createProductB() {
        return new ProductB_2();
    }
}

（2）产品

package FactoryPattern.AbstractFactoryPattern;

/**
 * 抽象产品
 */
public interface Product {
    public void operate();
}

package FactoryPattern.AbstractFactoryPattern;

/**
 * 具体产品A
 */
public interface ProductA extends Product {

    public void operateA();
}

package FactoryPattern.AbstractFactoryPattern;

/**
 * 具体产品B
 */
public interface ProductB extends Product {

    public void operateB();
}

package FactoryPattern.AbstractFactoryPattern;

import FactoryPattern.FactoryFunctionPattern.Product;

/**
 * 具体产品A
 */
public class ProductA_1 implements ProductA {
    @Override
    public void operate() {
        System.out.println("产品A_1的基本功能");
    }

    @Override
    public void operateA() {
        System.out.println("产品A_1的特别功能");
    }
}

package FactoryPattern.AbstractFactoryPattern;

import FactoryPattern.FactoryFunctionPattern.Product;

/**
 * 具体产品A
 */
public class ProductA_2 implements ProductA {
    @Override
    public void operate() {
        System.out.println("产品A_2的基本功能");
    }

    @Override
    public void operateA() {
        System.out.println("产品A_2的特别功能");
    }
}

package FactoryPattern.AbstractFactoryPattern;

import FactoryPattern.FactoryFunctionPattern.Product;

/**
 * 具体产品B
 */
public class ProductB_1 implements ProductB {
    @Override
    public void operate() {
        System.out.println("产品B_1的基本功能");
    }

    @Override
    public void operateB() {
        System.out.println("产品B_1的特别功能");
    }
}

package FactoryPattern.AbstractFactoryPattern;

import FactoryPattern.FactoryFunctionPattern.Product;

/**
 * 具体产品B
 */
public class ProductB_2 implements ProductB {
    @Override
    public void operate() {
        System.out.println("产品B_2的基本功能");
    }

    @Override
    public void operateB() {
        System.out.println("产品B_2的特别功能");
    }
}

（3）测试

package FactoryPattern.AbstractFactoryPattern;

public class Test {
    public static void main(String[] args) {
        //组装第1组的产品
        Factory factory1 = new Factory1();
        ProductA a = factory1.createProductA();
        ProductB b = factory1.createProductB();
        a.operateA();
        b.operateB();
        //组装第2组的产品
        Factory factory2 = new Factory2();
        a = factory2.createProductA();
        b = factory2.createProductB();
        a.operateA();
        b.operateB();

    }
}

3. 特点

• 系统的产品有多于一个的产品族，而系统只需要其中某一族的产品
• 起到了一定的约束作用，同属于同一个产品族的产品必须配套使用
• 切换产品族的时候，只要提供不同的抽象工厂实现就可以
• 不太容易扩展新的产品，需要修改抽象工厂