【设计模式】工厂模式

简单工厂模式

/**
 *	初始版本
 */
interface IProduct{
    void show();
}
class Product1 implements IProduct {

    @Override
    public void show() {
        System.out.println("Product1......");
    }
}
class Product2 implements IProduct{

    @Override
    public void show() {
        System.out.println("Product2......");
    }
}
class SimpleFactory{
	public SimpleFactory(){}
    public IProduct makeProduct(String type){
        if (type.equals("1")){
            return new Product1();
        }else if(type.equals("2")){
            return new Product2();
        }
        return null;
    }
}



/*
 * 优化2.0
 */
class SimpleFactory{
    public SimpleFactory(){}
    public IProduct makeProduct(String className){

        try {
            if(!(className==null || "".equals(className))){
                //通过反射的方式实现,不再使用固定的编号
                return (IProduct) Class.forName(className).newInstance();
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }
}



/*
 *	优化3.0
 */
class SimpleFactory{
    public SimpleFactory(){}
    public IProduct makeProduct(Class<? extends IProduct> clazz){
        try {
            if(clazz != null){
                return clazz.newInstance();
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }
}

优点

• 简单，方便

缺点

• 工厂类单一
• 数量多时，代码臃肿，会违背高聚合原则

应用

• JDK中的Calendar.getInstance()

工厂方法模式

interface IProduct{
    void doSomething();
}
interface IFactory{
    IProduct makeProduct();
}
class ConcreteProductA implements IProduct{

    @Override
    public void doSomething() {
        System.out.println("A...doSomething");
    }
}
class ConcreteProductB implements IProduct{

    @Override
    public void doSomething() {
        System.out.println("B...doSomething");
    }
}
class ConcreteProductC implements IProduct{

    @Override
    public void doSomething() {
        System.out.println("C...doSomething");
    }
}
class ConcreteFactoryA implements IFactory{

    @Override
    public IProduct makeProduct() {
        return new ConcreteProductA();
    }
}
class ConcreteFactoryB implements IFactory{

    @Override
    public IProduct makeProduct() {
        return new ConcreteProductB();
    }
}
class ConcreteFactoryC implements IFactory{

    @Override
    public IProduct makeProduct() {
        return new ConcreteProductC();
    }
}

优点

• 灵活。新产品的创建，只需要多写一个相应的工具类
• 解耦。高层模块只需要知道产品的抽象类，不用关心其他类。满足迪米特法则、依赖倒置和里氏代换原则

缺点

• 类的数量多，复制
• 增加了系统的抽象性和理解难度
• 抽象产品只能生产一种产品（抽象工厂解决）

抽象工厂模式

理解

视频学习：看视频、做笔记（看java视频，做java笔记；看python视频，做python笔记）

Factory相当于java、python…

ProductA相当于看视频

ProductB相当于做笔记

产品族：java、python…

产品：看视频、做笔记

interface IFactory{
    //工厂产品族的产品被规定了，扩展产品困难，但是增加产品族容易
    IProductA createA();
    IProductB createB();
}
interface IProductA{
    void doA();
}
interface IProductB{
    void doB();
}
class ConcreteProductAWithFactoryA implements IProductA{

    @Override
    public void doA() {
        System.out.println("The ProductA with FactoryA");
    }
}
class ConcreteProductBWithFactoryA implements IProductB{

    @Override
    public void doB() {
        System.out.println("The ProductB with FactoryA");
    }
}
class ConcreteProductAWithFactoryB implements IProductA{

    @Override
    public void doA() {
        System.out.println("The ProductA with FactoryB");
    }
}
class ConcreteProductBWithFactoryB implements IProductB{

    @Override
    public void doB() {
        System.out.println("The ProductB with FactoryB");
    }
}
class ConcreteFactoryA implements IFactory{

    @Override
    public IProductA createA() {
        return new ConcreteProductAWithFactoryA();
    }

    @Override
    public IProductB createB() {
        return new ConcreteProductBWithFactoryA();
    }
}
class ConcreteFactoryB implements IFactory{

    @Override
    public IProductA createA() {
        return new ConcreteProductAWithFactoryB();
    }

    @Override
    public IProductB createB() {
        return new ConcreteProductBWithFactoryB();
    }
}

优点

• 可以保证用户始终使用同一产品族
• 增加了可扩展性，对于新的产品族的增加，只需要实现一个具体工厂，符合开闭原则。

缺点

• 固定了所有可能被创建的产品，扩展新的产品困难，需要修改工厂类的接口。

• 增加了系统的抽象性和理解难度

应用

• JDBC的pool抽象类
• DBConnectionPool数据库连接池
• Spring中的BeanFactory