工廠模式定義 Define an interface for creating an object,but let subclasses decide which class to instantiate.Factory Method lets a class defer instantiation to subclasses.（定義一個用于創建對象的接口，讓子類決定實例化哪一個類。工廠方法使一個類的實例化延遲到其子類）

• 類圖比較簡單，AbstractCarFactory是一個抽象類，CarFactory為實現類，完成具體的任務——創建車；Car接口是車類的總稱，其三個實現類分別為三類車；Client類是一個場景類，負責模擬這個造車場景，執行相關的任務。

image.png

看一個簡單的例子

//接口
public interface Car {

    //每個車都有顏色
    public void getColor();

    //每個車都有輪胎顏色
    public void getTire();
}

//實現類
public class AudiBlackCar implements Car {
    @Override
    public void getColor() {
        System.out.println("黑色奧迪車");
    }

    @Override
    public void getTire() {
        System.out.println("黑色輪胎");
    }
}

//實現類
public class AudiRedCar implements Car {
    @Override
    public void getColor() {
        System.out.println("紅色奧迪車");
    }

    @Override
    public void getTire() {
        System.out.println("紅色輪胎");
    }
}

//實現類
public class AudiWhiteCar implements Car {
    @Override
    public void getColor() {
        System.out.println("白色奧迪車");
    }

    @Override
    public void getTire() {
        System.out.println("白色輪胎");
    }
}

//抽象工廠類
public abstract class AbstractCarFactory {
    public abstract <T extends Car> T createCar(Class<T> c);
}

//實現類
public class CarFactory extends AbstractCarFactory {
    @Override
    public <T extends Car> T createCar(Class<T> c) {
        //定義一個車
        Car car = null;
        try {
            car = (T)Class.forName(c.getName()).newInstance();
        }catch (Exception e) {
            System.out.println("車生產錯誤");
        }
        return (T)car;
    }
}

//客戶端
public class Client {

    public static void main(String[] args) {
        AbstractCarFactory carFactory = new CarFactory();
        AudiBlackCar audiBlackCar = carFactory.createCar(AudiBlackCar.class);
        audiBlackCar.getColor();
        audiBlackCar.getTire();
        System.out.println("+++++++++++++++++++++");
        AudiWhiteCar audiWhiteCar = carFactory.createCar(AudiWhiteCar.class);
        audiWhiteCar.getColor();
        audiWhiteCar.getTire();
        System.out.println("+++++++++++++++++++++");
        AudiRedCar audiRedCar = carFactory.createCar(AudiRedCar.class);
        audiRedCar.getColor();
        audiRedCar.getTire();
    }
}

以上就是一個簡單的工廠模式，造不同顏色的車，比較清晰明了

• 工廠模式的優點

1.良好的封裝性，代碼結構清晰。創建對象簡單只需要知道對象的類名就可以
2.比較容易擴展，增加產品的時候，只需要需改具體工廠類或者新增一個工廠類就可以。
3.屏蔽產品類。產品如何變化，調用者不需要關心，只需要關心接口。
4.工廠類典型解耦框架。高層模塊只需要知道產品的抽象類，其他不用關心。

• 工廠模式使用場景

1.需要靈活，可擴展框架時候可以考慮工廠模式
2.說白了工廠類就是new一個對象的替代品。

• 工廠模式擴展

1. 把上面例工廠類可以擴展為靜態方法

public class EnhangeCarFactory {
    public static   <T extends Car> T createCar(Class<T> c) {
        //定義一個車
        Car car = null;
        try {
            car = (T)Class.forName(c.getName()).newInstance();
        }catch (Exception e) {
            System.out.println("車生產錯誤");
        }
        return (T)car;
    }
}

2. 把上面例子升級多個工廠：目的是把所有產品放到一個工廠方法里面有可能結構不清晰。現在把生產每種顏色的車工廠都定義一個創造者，讓調用者自己去選擇與那個工廠關聯。

主要代碼如下

//抽象類
public abstract class AbstractEnCarFactory {
    public abstract Car createCar();
}

//實現類
public class AudiBlackCarFactory extends AbstractEnCarFactory {

    @Override
    public Car createCar() {
        return new AudiBlackCar();
    }
}

//實現類
public class AudiRedCarFactory extends AbstractEnCarFactory {
    @Override
    public Car createCar() {
        return new AudiRedCar();
    }
}

//實現類
public class AudiWhiteCarFactory extends AbstractEnCarFactory {
    @Override
    public Car createCar() {
        return new AudiWhiteCar();
    }
}

public class Client {

    public static void main(String[] args) {
        Car audiBlackCar = new AudiBlackCarFactory().createCar();
        audiBlackCar.getColor();
        audiBlackCar.getTire();
        Car audiRedCar = new AudiRedCarFactory().createCar();
        audiRedCar.getColor();
        audiRedCar.getTire();
        Car audiWhiteCar = new AudiWhiteCarFactory().createCar();
        audiWhiteCar.getColor();
        audiWhiteCar.getTire();
    }
}

image.png

以上就是工廠模式的基本簡單用法，歡迎大家查看并指出不足的地方，萬分感謝