设计模式应知应会——抽象工厂模式

一、简单工厂模式

定义： 专门定义一个类用来负责创建其他类的实例，被创建的类通常具有共同的父类(没有也行)

//产品类：
public interface Product {
    void hasFeature();
}

//继承产品的子类A产品
public class ProductA implements Product {
      public void hasFeature() {
          System.out.println("A产品的特点：好看！");
      }
  }

//继承产品的子类B产品
public class ProductB implements Product {
    public void hasFeature() {
        System.out.println("B产品的特点：实用！");
    }
}

对于产品实例的创建，我们可以创建一个工厂来负责创建他们，需要什么样的产品传入相应的产品参数

public class ProductFactory {
    public static Product createProduct(ProductType pt) throws Exception {
        switch (pt) {
            case PRODUCT_A:
                return new ProductA();
            case PRODUCT_B:
                return new ProductB();
            default:
                throw new Exception("请输入正确产品,才可以生产！");
        }
    }
}

public enum ProductType {
    PRODUCT_A,
    PRODUCT_B
}

//调用工厂为我们创建对象
public class ToolUser {
    public static void main(String[] args) {
        try {
            //根据传入的参数选择创建的产品
            Product pa = ProductFactory.createProduct(ProductType.PRODUCT_A);
            pa.hasFeature();
            ProductB pb = (ProductB) ProductFactory.createProduct(ProductType.PRODUCT_B);
            pb.hasFeature();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

这种模式可以管理对象的创建，但是如果再生产一种产品C，需要改动工厂和枚举，耦合性比较大。

二、工厂方法模式

定义： 创建一个生产对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类.

为了解决上述耦合过强的问题，我们将工厂类变得抽象，在工厂方法模式中，核心的工厂类不再负责所有的产品的创建，而是将具体创建的工作交给子类去做，工厂自身只提供创建产品的接口。

//工厂的作用就是生产产品
public interface Factory {
     Product createProduct();
}

//A工厂负责生产A产品
public class ProductAFactory implements Factory {
    public  Product createProduct() {
        return new ProductA();
    }
}

//B工厂负责生产B产品
public class ProductBFactory implements Factory {

    public Product createProduct() {
        return new ProductB();
    }
}


public class Main {
    public static void main(String[] args) {
        //工厂模式需要先创建相应产品工厂，再创建相应产品
        ProductAFactory pa = new ProductAFactory();
        pa.createProduct().hasFeature();

        ProductBFactory pb = new ProductBFactory();
        pb.createProduct().hasFeature();
    }
}
结果：
A产品的特点：好看！
B产品的特点：实用！

在上面的代码中，如果需要生产产品C,我们只需要实现工厂接口，创建C工厂类即可，这遵循了开闭原则：
对扩展开放，对修改关闭

三、抽象工厂模式

定义： 提供一个创建一系列相关或者相互依赖对象的接口，而无需指定他们具体的类.当一系列对象变成一种，这时就是工厂模式，可以看出工厂模式是抽象工厂模式的特例。

工厂模式中，在工厂中生产产品，产品是需要人使用的，所以可以在工厂中不仅指定生产产品，还可以指定产品使用者,我们还可以指定产品品牌，产品发货地等一系列特性。

//抽象工厂，用于指定生成产品和产品使用者
public interface AbstractFactory {
    //不必指定具体的产品类型，这里符合里氏替换原则，所有接受父类型的地方也需要接受子类型
    Product createProduct();

    Person createPerson();
}

//A产品工厂：生成A产品 使用者为A
public class ProductAFactory implements AbstractFactory {
    public Product createProduct() {
        return new ProductA();
    }

    public Person createPerson() {
        return new PersonA();
    }
}

//B产品工厂：生成B产品 使用者为B
public class ProductBFactory implements AbstractFactory {
    public Product createProduct() {
        return new ProductB();
    }

    public Person createPerson() {
        return new PersonB();
    }
}

//使用者接口
public interface Person {
    void say();
}

//A使用者
public class PersonA implements Person {
    public void say() {
        System.out.println("使用者A");
    }
}

//B使用者
public class PersonB implements Person {
    public void say() {
        System.out.println("使用者B");
    }
}

接下来开始加工生产：

public class Main {
    public static void main(String[] args) {
        ProductAFactory pa = new ProductAFactory();
        pa.createProduct().hasFeature();
        pa.createPerson().say();
        ProductBFactory pb = new ProductBFactory();
        pb.createProduct().hasFeature();
        pb.createPerson().say();
    }
}

结果：
A产品的特点：好看！
使用者A
B产品的特点：实用！
使用者B