设计模式学习笔记 - 工厂模式

对工厂模式的理解：根据传入的参数，用来生产具有共性的对象，且不对外暴露细节。

简单工厂模式 一个工厂类，对外提供工厂方法，传入参数，生产对应的对象。

缺点：具有局限性。如果要扩展，需要修改原来的类，增加else判断。违背了 “开闭原则”原则。

public class SimpleFactory {
    public static Product getProduct(String type) {
        if ("A".equals(type)) {
            return new ConcreteProductA();
        }
        if ("B".equals(type)) {
            return new ConcreteProductB();
        }
        return new ConcreteProductA();
    }
}

工厂方法模式 由于简单工厂的缺点，工厂方法则，很好的解决了修改原来类的缺点。

定义：用接口对工厂类进行规范的定义。每个工厂只对应每个抽象的产品类。如果需要扩展，则继承抽象类。

缺点：工厂的实现类会增加，产生冗余，意义不大。

来自 Android源码设计模式解析与实战 的例子：

抽象的产品类

 public abstract class Product {
    public abstract void method();
}

抽象的工厂类

public abstract class Factory {
    public abstract Product createProduct();
}

---

具体的产品类A

 public class ConcreteProductA extends Product {
    @Override
    public void method() {
        System.out.println("我是具体的产品A");
    }
}

具体的产品类B

public class ConcreteProductB extends Product {
    @Override
    public void method() {
        System.out.println("我是具体的产品B");
    }
}

---

对应的产品类的具体工厂方法

生产工厂A

 public class ConcreteFactoryA extends Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

生产工厂B

public class ConcreteFactoryB extends Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

---

角色总结：

1.抽象工厂，为工厂方法的核心 2.具体工厂，体现了具体的业务逻辑 3.抽象产品，产品的父类 4.具体产品，实现抽象产品的某个具体产品的对象

抽象工厂模式

和简单工厂很像，和工厂方法模式也很像。 定义工厂类，对外提供具体的产品抽象的特定方法。定义和BitmapFactory一样。

舍弃繁杂冗余的Factory接口和实现类，创建简单工厂方法+泛型，通过特定的方法返回单一的对象。

 public abstract class Factory1 {
    public abstract <T extends Product> Product createProduct(Class<T> clz);
}

public class ProductFactory extends Factory1 {
    private static volatile ProductFactory mInstance;

    public static ProductFactory getInstance() {
        if (mInstance == null) {
            synchronized (ProductFactory.class) {
                if (mInstance == null) {
                    mInstance = new ProductFactory();
                }
            }
        }
        return mInstance;
    }
    @Override
    public <T extends Product> Product createProduct(Class<T> clz) {
        try {
            return clz.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return new ConcreteProductA();
    }

    private Product mConcreteProductA;
    private Product mConcreteProductB;

    public Product getConcreteProductA() {
        if (mConcreteProductA == null) {
            mConcreteProductA = createProduct(ConcreteProductA.class);
        }
        return mConcreteProductA;
    }

    public Product getConcreteProductB() {
        if (mConcreteProductB == null) {
            mConcreteProductB = createProduct(ConcreteProductB.class);
        }
        return mConcreteProductB;
    }
}