一分钟读懂设计模式--工厂模式

一、简单工厂模式

1具体的工厂类有一个create的方法，利用if/switch返回具体产品

2create方法通常时静态，所以也叫静态工厂。

缺点：扩展性差，要增加一个产品，还需要修改工厂类方法

           不同产品需要不同额外的参数时，不支持。

//面条,最好都用接口
public interface  INoodles {
    //描述面条的
    void desc();
}

public class LZNoodles implements INoodles {
    @Override
    public void desc() {
        System.out.println("兰州拉面 上海的好贵 家里才5 6块钱一碗");
    }
}

public class RGMNoodles implements INoodles {
    @Override
    public void desc() {
        System.out.println("武汉正宗热干面");
    }
}

public class SimpleNoodlesFactory {
    public static final int TYPE_LZ = 1;//兰州拉面
    public static final int TYPE_RGM = 3;//热干面

    public static INoodles createNoodles(int type) {
        switch (type) {
            case TYPE_LZ:
                return new LZNoodles();
            case TYPE_RGM:
            default:
                return new RGMNoodles();
        }
    }
}

二、工厂方法

解决了简单工厂 : 不支持不同产品需要不同额外的参数。现在只要为自己产品添加参数就行，不影响其他

                            新增一个产品时，需要改工厂方法的问题。现在只要新增一个产品实现INoodles,一个工厂实现NoodlesFactory,再调用就好。

缺点：产品多，比较麻烦，需要增加好多产品的工厂类。

//面条接口
public interface INoodles {
    //描述面条的
    void desc();
}
//产品--兰州拉面
public class LZNoodles implements INoodles {
    @Override
    public void desc() {
        System.out.println("兰州拉面 上海的好贵 家里才5 6块钱一碗");
    }
}
//产品--热干面
public class RGMNoodles implements INoodles {
    @Override
    public void desc() {
        System.out.println("武汉正宗热干面");
    }
}

//工厂类接口
public interface NoodlesFactory {
    INoodles createNoodles();
}
//热干面工厂
public class RGMFactory implements NoodlesFactory{

    @Override
    public INoodles createNoodles() {
        return new RGMNoodles();
    }
}
//兰州拉面工厂
public class LZFactory implements NoodlesFactory {
    @Override
    public INoodles createNoodles() {
        return new LZNoodles();
    }
}

//使用
LZFactory lzFactory = new LZFactory();
INoodles iNoodles2 = lzFactory.createNoodles();
iNoodles2.desc();

RGMFactory rgmFactory = new RGMFactory();
INoodles iNoodles3 = rgmFactory.createNoodles();
iNoodles3.desc();

三、抽象工厂

抽象工厂一般是用在较复杂的，生产工厂交叉。

比如横向对比，产品分产品A和产品B;纵向划分，可以分产品1和产品2。

生产线1生产产品1，生产线2生产产品2。

//抽象产品A
public abstract class AbstractProductA {
    public abstract void method();
}
//抽象产品B
public abstract class AbstractProductB {
    public abstract void method();
}
//具体产品A1
public class ConcreteProductA1 extends AbstractProductA {
    @Override
    public void method() {
        System.out.println("具体产品A1的方法");
    }
}
//具体产品A2
public class ConcreteProductA2 extends AbstractProductA {
    @Override
    public void method() {
        System.out.println("具体产品A2的方法");
    }
}
//具体产品B1
public class ConcreteProductB1 extends AbstractProductB {
    @Override
    public void method() {
        System.out.println("具体产品B1的方法");
    }
}
//具体产品B2
public class ConcreteProductB2 extends AbstractProductB {
    @Override
    public void method() {
        System.out.println("具体产品B2的方法");
    }
}
//抽象共产
public abstract class AbstractFactory {
    public abstract AbstractProductA createProductA();
    public abstract AbstractProductB createProductB();

}
//具体工厂1--生产A1,B1
public class ConcreteFactory1 extends AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ConcreteProductA1();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ConcreteProductB1();
    }
}
//具体工厂2--生产A2,B2
public class ConcreteFactory2 extends AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ConcreteProductA2();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ConcreteProductB2();
    }
}

 

总结：都是不用管如何创建具体产品，通过工厂去获取就行。