【JavaSE】解释三种工厂设计模式-----简单工厂模式、工厂方法模式、抽象工厂模式。

一、简单工厂模式

简单工厂就是有一个工厂的接口，然后将实现接口子类的实例化操作放在另一个实现类中
然后这个类通过接受的参数来决定实现什么类，参数由客户端传入

interface INoodles{   //抽象产品
    public void desc();
}

class LzNoodles implements INoodles{  // 具体产品

    @Override
    public void desc() {
        System.out.println("兰州拉面");
    }
}

class PaoNoodles implements INoodles{  //具体产品

    @Override
    public void desc() {
        System.out.println("泡面");
    }
}

class GanNoodles implements INoodles{  //具体产品

    @Override
    public void desc() {
        System.out.println("干拌面");
    }
}

class CreateNoodles{    //具体工厂
    public INoodles create(int count){
        switch (count){
            case 1:return new LzNoodles();
            case 2:return new PaoNoodles();
            case 3:return new GanNoodles();
        }
        return new LzNoodles();
    }
}

public class Test {   //客户端
    public static void main(String[] args) {
        INoodles noodles = new CreateNoodles().create(2);
        noodles.desc();
    }
}

简单工厂的缺点就是：使用了switch-case，这样的话想要再添加一种产品，就得修改具体工厂类中的代码，违背了开-闭原则。

二、工厂方法模式

工厂方法模式基本解决了简单工厂的开-闭原则问题，当我们想要加入新产品的时候，不需要改变具体工厂类中具体的代码。
只需要添加一个子类，它需要实现抽象工厂的接口，然后在客户端中的代码稍微修改，就可以产生新产品了。

interface INoodles {         //抽象产品
    public void desc();
}

class LzNoodles implements INoodles{   //具体产品

    @Override
    public void desc() {
        System.out.println("兰州拉面");
    }
}

class PaoNoodles implements INoodles{   //具体产品

    @Override
    public void desc() {
        System.out.println("泡面");
    }
}

class GanNoodles implements INoodles{   //具体产品

    @Override
    public void desc() {
        System.out.println("干拌面");
    }
}

interface CreateNoodles{    //抽象工厂
    public INoodles createNoodles();
}

class CreateLz implements CreateNoodles{    //具体工厂

    @Override
    public INoodles createNoodles() {
        return new LzNoodles();
    }
}

class CreatePao implements CreateNoodles{  //具体工厂

    @Override
    public INoodles createNoodles() {
        return new PaoNoodles();
    }
}

class CreateGan implements CreateNoodles{  //具体工厂

    @Override
    public INoodles createNoodles() {
        return new GanNoodles();
    }
}

public class Test {   //客户端
    public static void main(String[] args) {
        CreateNoodles createNoodles = new CreateLz();
        INoodles noodles = createNoodles.createNoodles();
        noodles.desc();
    }
}

工厂方法模式完美的运用了java的面向对象和多态特性。比如：现在要新加一种面，龙须面，就得创建一个龙须面具体产品类，然后创建一个龙须面的具体工厂类。在客户端中选择CreateLong(龙须面)，就可以得到新产品了。不需要修改其他的代码。

三、抽象工厂模式

维基百科：抽象工厂模式是对一组具有相同主题的工厂进行封装。

• 抽象工厂模式就是一个工厂不可能只有一种产品，会有多种产品。
• 这些产品之间有着不同的产品等级。比如：第五代CPU和第七代CPU就是同一个产品等级（这样相同的产品等级的产品就用工厂方法去生成）
• 而CPU和内存就不是一个产品等级，但是它俩却是一个产品族，因为它俩都是生成电脑所需要的。
• 所以它们需要一个抽象工厂，这个工厂生产这些产品族最后组装起来的各种品牌产品。比如：战神电脑和联想电脑。
• 工厂方法模式解决的范畴是产品等级（AMD处理器，Intel处理器等）；抽象工厂模式解决的范畴是产品族等级（联想PC、惠普PC等）；

interface CPU{  //抽象产品
    void desc();
}

interface MEM{   //抽象产品
    void desc();
}

class HaseeCPU implements CPU {   //具体产品

    @Override
    public void desc() {
        System.out.println("战神CPU");
    }
}

class HaseeMEM implements MEM{  //具体产品

    @Override
    public void desc() {
        System.out.println("战神内存");
    }
}

class LenovoCPU implements CPU{  //具体产品

    @Override
    public void desc() {
        System.out.println("联想CPU");
    }
}

class LenovoMEM implements MEM {   //具体产品

    @Override
    public void desc() {
        System.out.println("联想内存");
    }
}

interface PCFactory{   //抽象工厂
    public CPU createCPU();
    public MEM createMEM();
}

class HaseeFactory implements PCFactory{   //具体工厂


    @Override
    public CPU createCPU() {
        return new HaseeCPU();
    }

    @Override
    public MEM createMEM() {
        return new HaseeMEM();
    }
}

class LenovoFactory implements PCFactory{ //具体工厂


    @Override
    public CPU createCPU() {
        return new LenovoCPU();
    }

    @Override
    public MEM createMEM() {
        return new LenovoMEM();
    }
}

public class Test {   //客户端
    public static void main(String[] args) {
        PCFactory pcFactory = new HaseeFactory();
        CPU cpu = pcFactory.createCPU();
        MEM mem = pcFactory.createMEM();
        cpu.desc();
        mem.desc();
    }
}

• 下面用一张图理解一下代码：
  

四、总结

• 简单工厂模式：可以实现由用户决定生产某一种商品，但是它内部的代码是switch-case，要添加一个新产品，就得改代码，违背了开闭原则。
• 工厂方法模式：通过将生产商品的过程延续到子类去实现，添加一个新产品，只需要添加一个子类就行了，但是不能解决多种不同产品等级的问题。
• 抽象工厂模式：多种不同产品等级，就是一堆相同产品族的不同等级产品要生产一种商品，可以将不同产品等级的方法抽象起来，综合在一个抽象工厂中。抽象工厂，接收各个产品接口创建的产品，然后通过具体工厂组装成最终的商品。
• PS：我感觉工厂方法多创建一个抽象产品和具体产品，然后就把它写进抽象工厂中，用具体工厂实现游一下。这样就把工厂方法模式提升为抽象工厂模式了。