工厂模式

一、定义

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

优点：良好的封装性，代码结构清晰，扩展性强，屏蔽产品类。

二、实现

public class Client {
    public static void main(String[] args) {
        Factory factory = new ConcreteFactory();
        Product product1 = factory.createProduct(ConcreteProduct1.class);
        Product product2 = factory.createProduct(ConcreteProduct2.class);
    }
}

//抽象产品类
abstract class Product {
    //产品类的公共方法
    public void method1(){
        //业务逻辑处理
    }
    //抽象方法
    public abstract void method2();
}

//具体产品类
class ConcreteProduct1 extends Product {
    public void method2() {
        //业务逻辑处理
    }
}

class ConcreteProduct2 extends Product {
    public void method2() {
        //业务逻辑处理
    }
}

//抽象工厂类
abstract class Factory {
    /*
     *创建一个产品对象，其输入参数类型可以自行设置
     *通常为String、Enum、Class等，当然也可以为空
     */
    public abstract  T createProduct(Class c);
}


//具体工厂类
class ConcreteFactory extends Factory {
    public  T createProduct(Class c) {
        Product product = null;
        try {
            product = (Product) Class.forName(c.getName()).newInstance();
        } catch (Exception e) {
            //异常处理
        }
        return (T) product;
    }
}

三、扩展

1. 缩小为简单工厂模式

public class Client {
    public static void main(String[] args) {
        Product product1 = SimpleFactory.createProduct(ConcreteProduct1.class);
        Product product2 = SimpleFactory.createProduct(ConcreteProduct2.class);
    }
}

//抽象产品类
abstract class Product {
    //产品类的公共方法
    public void method1(){
        //业务逻辑处理
    }
    //抽象方法
    public abstract void method2();
}

//具体产品类
class ConcreteProduct1 extends Product {
    public void method2() {
        //业务逻辑处理
    }
}

class ConcreteProduct2 extends Product {
    public void method2() {
        //业务逻辑处理
    }
}

class SimpleFactory {
    public static  T createProduct(Class c) {
        //定义一个生产出的产品
        Product product = null;
        try {
            //产生一个产品
            product = (Product) Class.forName(c.getName()).newInstance();
        } catch (Exception e) {
            //异常情况
        }
        return (T) product;
    }
}

2. 升级为多个工厂类

public class Client {
    public static void main(String[] args) {
        Product product1 = new ConcreteFactory1().createProduct();
        Product product2 = new ConcreteFactory2().createProduct();
    }
}

//抽象产品类
abstract class Product {
    //产品类的公共方法
    public void method1(){
        //业务逻辑处理
    }
    //抽象方法
    public abstract void method2();
}

//具体产品类
class ConcreteProduct1 extends Product {
    public void method2() {
        //业务逻辑处理
    }
}

class ConcreteProduct2 extends Product {
    public void method2() {
        //业务逻辑处理
    }
}

//抽象工厂类
abstract class AbstractFactory {
    public abstract Product createHuman();
}

//具体工厂类
class ConcreteFactory1 {
    public Product createProduct() {
        return new ConcreteProduct1();
    }
}

class ConcreteFactory2 {
    public Product createProduct() {
        return new ConcreteProduct2();
    }
}

3. 延迟初始化

//tips:一个对象被消费完毕后，并不立刻释放，工厂类保持其初始状态，等待再次被使用。
public class Client {
    public static void main(String[] args) {
        Product product = ProductFactory.createProduct("Product1");
    }
}

//抽象产品类
abstract class Product {
    //产品类的公共方法
    public void method1(){
        //业务逻辑处理
    }
    //抽象方法
    public abstract void method2();
}

//具体产品类
class ConcreteProduct1 extends Product {
    public void method2() {
        //业务逻辑处理
    }
}

class ConcreteProduct2 extends Product {
    public void method2() {
        //业务逻辑处理
    }
}

class ProductFactory {
    private static final Map prMap = new HashMap();

    public static synchronized Product createProduct(String type){
        Product product = null;
        //如果Map中已经有这个对象
        if (prMap.containsKey(type)) {
            product = prMap.get(type);
        } else {
            if (type.equals("Product1")) {
                product = new ConcreteProduct1();
            } else {
                product = new ConcreteProduct2();
            }
            //同时把对象放到缓存容器中
            prMap.put(type, product);
        }
        return product;
    }
}

4. 替代单例模式

public class Client {
    public static void main(String[] args) {
        Singleton singleton = SingletonFactory.getSingleton();
    }
}

class Singleton {
    //不允许通过new产生一个对象
    private Singleton(){
    }
    public void doSomething(){
        //业务处理
    }
}


class SingletonFactory {
    private static Singleton singleton;
    static{
        try {
            Class cl= Class.forName(Singleton.class.getName());
            //获得无参构造
            Constructor constructor=cl.getDeclaredConstructor();
            //设置无参构造是可访问的
            constructor.setAccessible(true);
            //产生一个实例对象
            singleton = (Singleton)constructor.newInstance();
        } catch (Exception e) {
            //异常处理
        }
    }
    public static Singleton getSingleton(){
        return singleton;
    }
}