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

1、简单工厂模式

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

//产品类:
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产品的特色:实用!");
    }
}
复制代码

对于产品实例的建立,咱们能够建立一个工厂来负责建立他们,须要什么样的产品传入相应的产品参数spa

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,须要改动工厂和枚举,耦合性比较大。code

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、抽象工厂模式

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

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

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

接下来开始加工生产:it

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
复制代码
相关文章
相关标签/搜索