JAVA设计模式-工厂模式

前言：

复习设计模式，总结工厂模式

一、简介

工厂模式大致分为三种简单工厂模式（静态工厂）、工厂方法（工厂模式）、抽象工厂模式，三种模式复杂度依次增加，并解决了前一种模式的缺点

二、简单工厂模式

简单工厂模式又称为静态工厂，主要是在工厂类中实现对外提供的创建产品的逻辑方法，再根据外部调用该逻辑方法动态的创建相应的产品

主要角色：

工厂：实现创建产品的逻辑方法
抽象产品：抽象接口的定义，描述产品功能
具体产品：继承抽象产品并定义具体产品的实现逻辑

举例：

自动贩卖机（工厂），可以出售各种物品（抽象产品），点击贩卖机上的薯片（具体的产品）按钮则获得到薯片

抽象产品

public abstract class Product {

    abstract void produce();
}

具体产品A 生产薯片

public class AProduct extends Product{
    @Override
    void produce() {
        System.out.println("potato chips");
    }
}

具体产品B 生产可乐

public class BProduct extends Product{
    @Override
    void produce() {
        System.out.println("Cola");
    }
}

工厂

public class Factory {

    public static Product getProduct(String type) {
        switch (type) {
            case "potato chips":
                return new AProduct();
            case "Coal":
                return new BProduct();
            case "chick":
                return new CProduct();
            default:
                return null;
        }
    }
}

Main方法

public class Main {

    public static void main(String[] args) {
        Product aProduct = Factory.getProduct("potato chips");
        aProduct.produce();
        Product bProduct = Factory.getProduct("Coal");
        bProduct.produce();
        Product product = Factory.getProduct("balbala");
        if (product == null){
            System.out.println("无此产品");
        }
    }
}

结果
```
potato chips
Cola
无此产品
```
　　
优点：具体的产品干具体的事，解藕
缺点：每次增加新的产品需要改工厂的生产产品的逻辑方法，不符合“开放关闭原则”

三、工厂方法

由抽象工厂派生出的子工厂进行产品的生产，每个子工厂（具体工厂）只能生产一种具体的产品

主要角色：

抽象工厂：实现具体工厂的公共接口
具体工厂：创建具体产品
抽象产品：描述抽象产品
具体产品：描述具体产品

举例：

****自动贩卖机（抽象工厂），食品类出售口（具体工厂），食品类（抽象产品）有薯片/可乐/炸鸡，如果你想吃薯片（具体产品）则只需要去食品类出售口点薯片就行

抽象产品

public abstract class Product {

    abstract void produce();
}

具体产品A

public class AProduct extends Product{
    @Override
    void produce() {
        System.out.println("薯片");
    }
}

具体产品B

public class BProduct extends Product{
    @Override
    void produce() {
        System.out.println("可乐");
    }
}

抽象工厂

public abstract class Factory {

    abstract Product getProduct();

}

具体工厂A (只能生产薯片)

public class AFactory extends Factory{


    @Override
    Product getProduct() {
        return new AProduct();
    }

}

具体工厂B（只能生产可乐）

public class BFactory extends Factory{
    @Override
    Product getProduct() {
        return new BProduct();
    }
}

Main方法

public class Main {

    public static void main(String[] args) {
        AFactory aFactory = new AFactory();
        aFactory.getProduct().produce();
        BFactory bFactory = new BFactory();
        bFactory.getProduct().produce();
    }
}

结果
```
薯片
可乐
```
　　
优点：符合单一职责原则，每个工厂只负责创建对应的产品，符合开放闭合原则，只需要增加具体工厂和对应的具体产品
缺点：一个具体工厂只能生产一个具体产品，具体工厂和具体产品成对出现，代码复杂度上升

四、抽象工厂模式

抽象工厂派生的子工厂可以生产多个种类的产品，抽象产品派生出各个不同种类的抽象产品族（食物/饮料/生活用品），抽象产品族派生出具体产品（薯片/可乐）

主要角色：

抽象工厂：描述具体工厂的公共接口
具体工厂：创建具体产品，供外部调用
抽象产品：描述抽象产品的公共接口
抽象产品族：描述具体产品的公共接口
具体产品：描述具体产品**
**

举例： 自动贩卖机（抽象工厂），可以出售各类物品（抽象产品族），零食、饮料（抽象产品），食物贩卖窗口（具体工厂），可乐、薯片（具体产品）

抽象产品（可以生产产品的公共接口）

public abstract class Product {

    abstract void produce();
}

抽象产品族A（零食类）

public abstract class AProduct extends Product{

    @Override
    abstract void produce();

}

抽象产品族B（饮料类）

public abstract class BProduct extends Product{

    @Override
    abstract void produce();
}

具体产品AA（薯片）

public class ProductAA extends AProduct{
    @Override
    void produce() {
        System.out.println("薯片");
    }
}

具体产品BB（可乐）

public class ProductBB extends BProduct{
    @Override
    void produce() {
        System.out.println("可乐");
    }
}

抽象工厂（提供生产多种抽象产品的公共接口）

public abstract class Factory {

    abstract Product getProductA();

    abstract Product getProductB();

}

具体工厂（食物工厂，可以生产饮料和零食）

public class AFactory extends Factory{

    @Override
    Product getProductA() {
        return new ProductAA();
    }

    @Override
    Product getProductB() {
        return new ProductBB();
    }
}

Main方法 : 同一个具体的工厂可以产出多个种类的产品

   public static void main(String[] args) {
        //零食工厂
        AFactory aFactory = new AFactory();
        aFactory.getProductA().produce();
        aFactory.getProductB().produce();
    }

结果
```
薯片
可乐
```
　　
优点：解决了工厂方法只能一个具体工厂生产一种产品的缺陷
缺点：如果扩展新种类的产品比较麻烦

五、参考文档

www.jianshu.com/p/d951ac561…