设计模式之工厂模式把设计模式撸一遍，先从简单的开始。工厂模式的三种写法工厂模式：顾名思义，就是相当于工厂一样，制造产品

把设计模式撸一遍，先从简单的开始。工厂模式的三种写法

工厂模式分为简单工厂，工厂模式，抽象工厂

工厂模式：顾名思义，就是相当于工厂一样，制造产品一样，产品都有产品原型。而在程序就想当与是流水线一样。

工厂都有几个角色：

1：产品种类（汽水）

2：品牌（可口可乐，百事可乐，雪碧）

3：流水线

4：工人

这样就可以大概把一个工厂模型描绘出来了

什么是工厂模式：

场景，一家工厂，有好几家订单，都是生成汽水的。同样的流水线就可以生成出不同的品牌。那干嘛还要把品牌的概念换成产品的概念。同一产品只是品牌不同（同样的功能，只是功能实现的差别，当程序有同样功能但是这实现的方法或者使用上有差别的时候，就相当于汽水和百事可乐的概念）

为什么要使用工厂模式：

通过上面的场景就知道，当有不同实现但功能作用是一样的时候，方便得到这个品牌，也能节约成本

怎么实现如下：

简单工厂

Persi 和 coca-cola都是汽水 soda 。当继承了soda的时候就可以被plant生产出来

代码如下

public interface Soda {
    public void goodFlavour();
}

public class Coco implements Soda {
    public void goodFlavour() {
        System.out.println("Coco");
    }
}

public class Pepsi implements Soda {
    public void goodFlavour() {
        System.out.println("Pepsi");
    }
}

工厂

public class Plant {

    public static Soda getPepsi(String type){
        if ("百事可乐".equals(type)){
            return new Pepsi();
        }else if ("可口可乐".equals(type)){
            return new Coco();
        }
        return new Pepsi();
    }

}

main

public class Main {

    public static void main(String[] age){
        Soda 百事可乐 = Plant.getPepsi("百事可乐");
        百事可乐.goodFlavour();
    }
}

当指定百事可乐的时候就可以生成出指定的白色可乐出来

工厂模式

简单工厂缺点：当种类不断增多的时候，代码不断堆积也不好维护，就需要这种方式。

把工厂也抽象化，抽象工厂拥有生成抽象的产品能力。从而让实现工厂类有有相匹配生成产品的能力

就好比IFactory是拥有生成汽水的证明，IFactoryPepsi需要有这个证明才能生成Pepsi

代码如下

工厂抽象类和对应的实现类

public interface IFactory {

    public Soda getSoda();
}
public class FactoryPepsi implements IFactory {
    public Soda getSoda() {
        return new Pepsi();
    }
}
public class FactoryCoco implements IFactory {
    public Soda getSoda() {
        return new Coco();
    }
}

抽象产品和实现类

public class Coco implements Soda {
    public void goodFlavour() {
        System.out.println("Coco");
    }
}
public class Pepsi implements Soda {
    public void goodFlavour() {
        System.out.println("Pepsi");
    }
}

main

public class Main {

    public static void main(String[] age){
        FactoryCoco factoryCoco = new FactoryCoco();
        FactoryPepsi factoryPepsi = new FactoryPepsi();
        Soda soda1 = factoryPepsi.getSoda();
        soda1.goodFlavour();
        Soda soda = factoryCoco.getSoda();
        soda.goodFlavour();
    }
}

抽象工厂：

抽象工厂模式：更加把工厂概念抽象出来。工厂模式是把能生成产品工厂抽象出来，而抽象工厂更像是一个组合。比如工厂A能生产可乐也能生成怡宝。把工厂概念抽象，工厂模式是把生成功能抽象列出来。

代码如下：

工厂：

public interface Factory {

    public Water getWater();

    public Soda getSoda();

}
public class FactoryA implements Factory {
    public Water getWater() {
        return new WaHaHa();
    }

    public Soda getSoda() {
        return new Coco();
    }
}
public class FactoryB implements Factory {
    public Water getWater() {
        return new YiBao();
    }

    public Soda getSoda() {
        return new Pepsi();
    }
}

不同的产品：

public interface Soda {
    public void goodFlavour();
}
public interface Water {

    public void goodWater();
}
public class WaHaHa implements Water {
    public void goodWater() {
        System.out.println("WaHaHa");
    }
}
public class Coco implements Soda {
    public void goodFlavour() {
        System.out.println("Coco");
    }
}public class Pepsi implements Soda {
    public void goodFlavour() {
        System.out.println("Pepsi");
    }
}public class YiBao implements Water {
    public void goodWater() {
        System.out.println("YiBao");
    }
}

main

public class Main {

    public static void main(String[] age){
        FactoryA factoryA = new FactoryA();
        Soda soda = factoryA.getSoda();
        soda.goodFlavour();
        FactoryB factoryB = new FactoryB();
        Water water = factoryB.getWater();
        water.goodWater();
    }

}

介绍完成，想简单点，抽象点。

因为是我自己看了之后，自己理解写的。不一定对，大家还是找官方文档看。谢谢