设计模式之——工厂模式

前言：
本文仅作为第一次学习设计模式的参考和笔记。
初探工厂模式&抽象工厂模式：

工厂模式：Factory Pattern

---

原话：Define an interface for creating an object , but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.
直译：定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

1. 定义：父类为抽象接口，子类实例化具体需求。

2. 示例类图：

工厂模式通用类图

3. 示例代码：

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

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

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

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

class ConcreteCreator extends Creator{
    public <T extends Product> T createProduct(Class<T> c){
        Product product = null;
        try{
            product = (Product)Class.forName(c.getName()).newInstance();
        }catch (Exception e){
            //异常处理
        }
        return (T)product;
    }

}

public class Client{
    public static void main(String[] args){
        Creator creator = new ConcreteCreator();
        Product product = creator.createProduct(ConcreteProduct1.class);
        /*
         * 继续业务处理
         */
    }
}

4. 优点：

• 良好的封装性，代码结构清晰
• 扩展性优秀
• 屏蔽产品类
• 解耦框架

5. 使用场景：

• 生成对象的地方，增加工厂类进行管理
• 需要灵活的、可扩展的框架时，万物街对象
• 异构项目
• 测试驱动

6. 扩展：

• 简单工厂模式：仅一个工厂，一个模块，用静态方法。

interface Human{
    //每个人种的皮肤都有相应的颜色
    public void getColor();
    //人类会说话
    public void talk();
}

class HumanFactory {
    static <T extends Human>T createHuman(Class<T> c){
        //定义一个生产出的人种
        Human human = null;
        try{
            //产生一个人种
            human = (Human)Class.forName(c.getName()).newInstance();
        }catch(Exception e){
            //错误
        }
        return (T)human;
    }
}

public class NvWa{
    public static void main(String[] args){
        Human whiteHuman = HumanFactory.createHuman(WhiteHuman.class);
        whiteHuman.getColor();
        whiteHuman.talk();
        
        Human blackHuman = HumanFactory.createHuman(BlackHuman.class);
        blackHuman.getColor();
        blackHuman.talk();
        
        Human yellowHuman = HumanFactory.createHuman(YellowHuman.class);
        yellowHuman.getColor();
        yellowHuman.talk();
    }
}

• 多个工厂类：

//多工厂模式：

abstract class AbstractHumanFactory{
    public abstract Human createHuman();
}

class BlackHumanFactory extends AbstractHumanFactory{
    public Human createHuman(){
        return new BlackHuman();
    }
}

class YellowHumanFactory extends AbstractHumanFactory{
    public Human createHuman(){
        return new YellowHuman();
    }
}

class WhiteHumanFactory extends AbstractHumanFactory{
    public Human createHuman(){
        return new WhiteHuman();
    }
}

public class NvWa{
    public static void main(String[] args){
        Human whiteHuman = (new WhiteHumanFactory()).createHuman();
        whiteHuman.getColor();
        whiteHuman.talk();
        
        Human blackHuman = (new BlackHumanFactory()).createHuman();
        blackHuman.getColor();
        blackHuman.talk();
        
        Human yellowHuman =(new YellowHumanFactory()).createHuman();
        yellowHuman.getColor();
        yellowHuman.talk();
    }
}

• 替代单例模式：在内存中只产生一个对象

//替代单例模式：

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

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

• 延迟初始化：一个对象结束后，不立即释放

//延迟加载的工厂类：
class ProductFactory{
    private static final Map<String,Product>prMap = new HashMap();
    public static synchronized Product createProduct(String type)throws Exception{
        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;
    }
}

抽象工厂模式：Abstract Factory Pattern

---

原话：Provide an interface for creating families of related or dependent objects without specifying their concrete classes.
直译：为创建一组相关或相互依赖的对象提供一个接口，而且无需指定它们的具体类。

1. 定义：一组抽象的产品类，共同继承或实现一个抽象类或接口，实现具体细化区分。

2. 示例类图：

抽象工厂通用类图

3.示例代码：

//抽象产品类A
abstract class abstractProductA{
    //每个产品共有的方法
    public void shareMethod(){
        
    }
    //每个产品相同方法，不同实现
    public abstract void doSomeThing();
}

//产品A1的实现类
class ProductA1 extends abstractProductA{
    public void doSomeThing(){
        //产品A1的实现方法
    }
}

//产品A2的实现类
class ProductA2 extends abstractProductA{
    public void doSomeThing(){
        //产品A2的实现方法
    }
}

//抽象产品类B
abstract class abstractProductB{
    //每个产品共有的方法
    public void shareMethod(){
        
    }
    //每个产品相同方法，不同实现
    public abstract void doSomeThing();
}

//产品A1的实现类
class ProductB1 extends abstractProductB{
    public void doSomeThing(){
        //产品A1的实现方法
    }
}

//产品A2的实现类
class ProductB2 extends abstractProductB{
    public void doSomeThing(){
        //产品A2的实现方法
    }
}

//抽象工厂类
abstract class AbstractCreator{
    //创建A产品家族
    public abstract abstractProductA createProductA();
    //创建B产品家族
    public abstract abstractProductB createProductB();
}


//生产等级为1的实现类
class Creator1 extends AbstractCreator{
    //只生产产品等级为1的A产品
    public abstractProductA createProductA(){
        return new ProductA1();
    }
    //只生产产品等级为1的B产品
    public abstractProductB createProductB(){
        return new ProductB1();
    }
}

//生产等级为2的实现类
class Creator2 extends AbstractCreator{
    //只生产产品等级为2的A产品
    public abstractProductA createProductA(){
        return new ProductA2();
    }
    //只生产产品等级为1的B产品
    public abstractProductB createProductB(){
        return new ProductB2();
    }
}

//场景类：
public class Client {
    public static void main(String[] args){
        //定义出两个工厂
        AbstractCreator creator1 = new Creator1();
        AbstractCreator creator2 = new Creator2();
        //产生A1对象
        abstractProductA a1 = creator1.createProductA();
        //产生A2对象
        abstractProductA a2 = creator2.createProductA();
        //产生B1对象
        abstractProductB b1 = creator1.createProductB();
        //产生B2对象
        abstractProductB b2 = creator2.createProductB();
        
        //...
    }
}

4. 优点：

• 封装性：高层模块不用关心产品的实现类
• 产品族内的约束非公开

5. 缺点：

• 扩展很难，改动很大，违背开闭原则

6. 使用场景：

一个对象族。

7. 注意事项：

产品族扩展困难，产品等级扩展简单。