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

1、简单工厂模式

定义： 专门定义一个类用来负责建立其余类的实例，被建立的类一般具备共同的父类(没有也行)

//产品类：
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，须要改动工厂和枚举，耦合性比较大。

2、工厂方法模式

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

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

//工厂的做用就是生产产品
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工厂类便可，这遵循了开闭原则：
对扩展开放，对修改关闭

3、抽象工厂模式

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

工厂模式中，在工厂中生产产品，产品是须要人使用的，因此能够在工厂中不只指定生产产品，还能够指定产品使用者,咱们还能够指定产品品牌，产品发货地等一系列特性。

//抽象工厂，用于指定生成产品和产品使用者
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
复制代码