設計模式之工廠模式（簡單工廠，工廠方法，抽象方法）

工廠模式

1、簡單工廠模式：

​ 首先我們有一個Car類，這個Car可以go：

public class Car {
    public void go() {
        System.out.println("car go ...");
    }
}

還有一個調用者，這樣就可以造出車來跑：

public class Main {
    public static void main(String[] args) {
        Car car = new Car();
        car.go();
    }
}

此時如果我們想把car換成plane，那就需要新加一個plane類，並且修改main:

public class Plane {
    public void go(){
        System.out.println("plane fly ... ");
    }
}

public class Main {
    public static void main(String[] args) {
//        Car car = new Car();
//        car.go();
        Plane plane = new Plane();
        plane.go();
    }
}

如果之後又要換成其他交通工具，那就得頻繁修改main中代碼，修改代碼是必須的，但是怎麼才能做到儘量少的修改代碼呢？這時我們把交通工具抽象出來。新建Moveable接口：

public interface Moveable {
    void go();
}

並且讓交通工具實現這個接口：

public class Car implements Moveable{
    public void go() {
        System.out.println("car go ...");
    }
}

public class Plane implements Moveable {
    public void go(){
        System.out.println("plane fly ... ");
    }
}

此時我們的main，當以後我們需要變換其他的交通工具時，只需要修改new後面的就可以，其他地方不用動：

public class Main {
    public static void main(String[] args) {
//        Car car = new Car();
//        car.go();
//        Plane plane = new Plane();
//        plane.go();
        Moveable m = new Car();
        m.go();
    }
}

現在我們已經實現了自由切換交通工具了，但是再思考一個問題：如果現在我們想在new交通工具的時候，再加一些流程，比如日誌，在每次造車前，記錄一下車的生產日期等等，而如果這些代碼都寫在main中，會有大量的if判斷，因爲有汽車，有飛機，有火車…它們的製作方法都是不一樣的，此時我們需要定義一個工廠：

public class SimpleFactory {
    
    public Car createCar()
    {
        // Do something before create car....
        return new Car();
    }

    public Plane createPlane()
    {
        // Do something before create plane....
        return new Plane();
    }
}

這個工廠負責每個交通工具生產前後的處理，而調用者一方只需要new一個工廠然後製造交通工具，其他的細節交給工廠來處理，這就是簡單工廠模式：

public static void main(String[] args) {
    Moveable m = new SimpleFactory().createCar();
    m.go();
}

這個方式存在的缺陷是每當新增一個新的交通工具時，還是需要在SimpleFactory類中新增方法，還是需要修改源碼，這還是不利於擴展，不符合開閉原則。所以我們現在考慮爲每一個產品設計一個工廠：

2、工廠方法

爲每一種交通工具設計工廠：

//造汽車的汽車工廠
public class CarFactory {
    public Moveable createCar()
    {
        // Do something before create car ...
        System.out.println("A car created!");
        return new Car();
    }
}

//造飛機的飛機工廠
public class PlaneFactory {
    public Moveable createPlane()
    {
        // Do something before create plane ...
        System.out.println("A plane created!");
        return new Plane();
    }
}

main:

public static void main(String[] args) {
    Moveable m = new CarFactory().createCar();
    m.go();
}

以後新增產品時，只需要新建一個產品類，然後新建一個對於該產品的工廠類（XXXFactory），這樣就不必修改源碼，即可完成拓展。

3、抽象工廠模式

考慮這樣一種情形，描述一個人他開什麼交通工具，穿什麼衣服，用什麼手機，這三類產品構成了產品簇

public class Car{
    public void go() {
        System.out.println("car go ...");
    }
}

public class Jeans {
     public void printName()
     {
         System.out.println("I'm wearing Jeans.");
     }
}

public class CellPhone {
    public void call()
    {
        System.out.println("Calling ...");
    }
}

main

public class Main {
    public static void main(String[] args) {
        Car car = new Car();
        car.go();

        Jeans jeans = new Jeans();
        jeans.printName();

        CellPhone cellPhone = new CellPhone();
        cellPhone.call();

    }
}

這樣描述的是一個人開着車，穿的是牛仔褲，用的是大哥大手機。現在考慮另一個人他開着飛機，穿着休閒服，用的是智能手機，那我們就需要建立飛機類，休閒服類，智能手機類：

public class Plane {
    public void go(){
        System.out.println("plane fly ... ");
    }
}

public class SmartPhone {
    public void call()
    {
        System.out.println("Calling ...");
    }
}

public class SportsWear {
    public void printName()
    {
        System.out.println("I'm wearing sportswear.");
    }
}

main:

public class Main {
    public static void main(String[] args) {
//        Car car = new Car();
//        car.go();
//
//        Jeans jeans = new Jeans();
//        jeans.printName();
//
//        CellPhone cellPhone = new CellPhone();
//        cellPhone.call();

        Plane plane = new Plane();
        plane.go();
        SportsWear s = new SportsWear();
        s.printName();
        SmartPhone smartPhone = new SmartPhone();
        smartPhone.call();

    }
}

當這個人是舊時代的，那他是駕馬車，穿舊時代的衣服，用書信進行溝通

當這個人是現代的，那他是開汽車，穿現代的衣服，用智能手機進行溝通

這就構成了產品族，我們如何靈活的組合不同類型的產品呢？

當前我們的代碼，如果我們想換產品族，就得修改全部的代碼：

Plane plane = new Plane();
plane.go();
SportsWear s = new SportsWear();
s.printName();
SmartPhone smartPhone = new SmartPhone();
smartPhone.call();

有沒有什麼方法可以靈活擴展產品族呢？

抽象工廠可以實現。

我們將三種產品分別抽象出：

// 交通工具抽象類
public abstract class Vehicle {
    public abstract void go();
}

// 衣着抽象類
public abstract class Clothes {
    public abstract void printName();
}

// 通訊工具抽象類
public abstract class CommunicationTools {
    public abstract void call();
}

在聲明一個抽象工廠,這個工廠可以生產交通工具，衣服，通訊工具：

public abstract class AbstractFactory {
    abstract Vehicle createVehicle();
    abstract Clothes createClothe();
    abstract CommunicationTools createCommunicationTool();
}

然後修改剛纔的產品繼承自抽象類：

public class Car extends Vehicle{
    public void go() {
        System.out.println("car go ...");
    }
}
public class Jeans extends Clothes{
     public void printName()
     {
         System.out.println("I'm wearing Jeans.");
     }
}
public class CellPhone extends CommunicationTools{
    public void call()
    {
        System.out.println("Calling ...");
    }
}
//....

現在我們新建一個ModernFactory，這個工廠繼承自AbstractFactory，它負責提供汽車，休閒裝，智能手機：

public class ModernFactory extends AbstractFactory {
    @Override
    Vehicle createVehicle() {
        return new Car();
    }

    @Override
    Clothes createClothe() {
        return new SportsWear();
    }

    @Override
    CommunicationTools createCommunicationTool() {
        return new SmartPhone();
    }
}

修改我們的main

public class Main {
    public static void main(String[] args) {
        AbstractFactory factory = new ModernFactory();
        Clothes clothe = factory.createClothe();
        CommunicationTools tool = factory.createCommunicationTool();
        Vehicle vehicle = factory.createVehicle();
    }
}

這樣做的好處就是當我們需要不同的產品族時，只需要新增對應產品的類，新增工廠類，然後直接修改AbstractFactory factory = new ModernFactory();這一行代碼即可，其他地方完全不用動。

工廠方法可以靈活的實現橫向產品擴展，抽象工廠可以靈活的定製產品族，這兩種模式一個有利於橫向產品擴展，一個有利於縱向的產品族定製。