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

工厂模式: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.

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

定义:

父类为抽象接口,子类实例化具体需求。

示例类图:

工厂模式通用类图

示例代码:
//抽象产品类:
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);
        /*
         * 继续业务处理
         */
    }
}
优点:
  • 良好的封装性,代码结构清晰
  • 扩展性优秀
  • 屏蔽产品类
  • 解耦框架
使用场景:
  • 生成对象的地方,增加工厂类进行管理
  • 需要灵活的、可扩展的框架时,万物街对象
  • 异构项目
  • 测试驱动
扩展:
  • 简单工厂模式:仅一个工厂,一个模块,用静态方法。
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. 直译:为创建一组相关或相互依赖的对象提供一个接口,而且无需指定它们的具体类。

定义:

一组抽象的产品类,共同继承或实现一个抽象类或接口,实现具体细化区分。

示例类图:

抽象工厂通用类图

示例代码:

//抽象产品类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();

        //...
    }
}
优点:
  • 封装性:高层模块不用关心产品的实现类
  • 产品族内的约束非公开
缺点:
  • 扩展很难,改动很大,违背开闭原则
使用场景:

一个对象族。

注意事项:

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