簡單工廠
簡單工廠模式又 叫靜態工廠方法模式（Static FactoryMethod Pattern）,是通過專門定義一個類來負責創建其他類的實例，被創建的實例通常都具有共同的父類。
簡單工廠定義一個Factory類，可以根據參數的不同返回不同類的實例，被創建的實例通常有共同的父類。實質是由一個工廠類根據傳入的參數，動態決定應該創建哪一個產品類實例。
在實際使用過程中，違背了 開放-關閉原則，因此並不屬於23中設計模式之一。
結構圖：
- Product：抽象產品類，將具體產品類公共的代碼進行抽象和提取後封裝在一個抽象產品類中。
- ConcreteProduct：具體產品類，將需要創建的各種不同產品對象的相關代碼封裝到具體產品類中。
- Factory：工廠類，提供一個工廠類用於創建各種產品，在工廠類中提供一個創建產品的工廠方法，該方法可以根據所傳入參數的不同創建不同的具體產品對象。
- Client：客戶端類，只需調用工廠類的工廠方法並傳入相應的參數即可得到一個產品對象。
代碼實現：
abstract class Car {
public abstract void run();
}
//實現接口
class Audi extends Car {
@Override
public void run() {
System.out.println("奧迪跑的快");
}
}
class Byd extends Car {
@Override
public void run() {
System.out.println("比亞迪跑的慢");
}
}
//接下來需要解決的就是對象的創建問既如何根據不同的情況創建不同的對象：我們正好可以通過簡單工廠模式實現
class CarFactory {
public static Car createCar(String type){
switch (type){
case "audi" : return new Audi();
case "byd" : return new Byd();
default:break;
}
return null;
}
}
//調用：
public class SimpleFactory {
public static void main(String[] args) {
Car c1 =CarFactory.createCar("audi");
Car c2 = CarFactory.createCar("byd");
c1.run();
c2.run();
}
}
工廠方法
工廠方法模式，又稱工廠模式，通過定義工廠父類負責定義創建對象的公共接口，而子類則負責生成具體的對象。將類的實例化（具體產品的創建）延遲到工廠類的子類（具體工廠）中完成，即由子類來決定應該實例化（創建）哪一個類。主要解決了簡單工廠模式的缺點（工廠一旦需要生產新產品就需要修改工廠類的方法邏輯，違背了“開放 - 關閉原則）
結構圖
- product：抽象產品，具體產品的父類，描述具體產品的公共接口
- concrete product：具體產品，抽象產品的子類，工廠類創建的目標類，描述生產的具體產品
- creator：抽象工廠，具體工廠的父類，描述具體工廠的公共接口
- concrete creator：具體工廠，抽象工廠的子類，被外界調用，描述具體工廠，創建產品的實例
代碼
interface CarFactory{
Car createCar();
}
interface Car{
void run();
}
//實現工廠類
class AudiFactory implements CarFactory {
@Override
public Car createCar() {
return new Audi();
}
}
class BydFactory implements CarFactory {
@Override
public Car createCar() {
return new Byd();
}
}
//實現產品類
class Audi implements Car {
@Override
public void run() {
System.out.println("奧迪再跑！");
}
}
class Byd implements Car {
@Override
public void run() {
System.out.println("比亞迪再跑！");
}
}
public class FactoryMethod {
public static void main(String[] args) {
Car c1 = new AudiFactory().createCar();
Car c2 = new BydFactory().createCar();
c1.run();
c2.run();
}
}
工廠模式在保留了簡單工廠的封裝優點的同時，讓擴展變得簡單，讓繼承變得可行，增加了多態性的體現。但是，在添加新產品時，除了要添加新產品類以外，還要提供一直對應的具體工廠類，另外，雖然保證了工廠方法內對修改關閉，但是如果更換另一種產品，仍然需要修改實例化的具體工廠類，一種具體工廠只能創建一種具體產品。
抽象工廠
抽象工廠模式的適用範圍比工廠模式更加廣泛，它與工廠模式最大的區別在於：
工廠模式中一個工廠只能生產一種產品，而抽象工廠可以生產多個。
結構圖：
代碼：
interface CarFactory {
Engine createEngine();
Seat createSeat();
}
interface Engine {
void run();
void start();
}
interface Seat {
void massage();
}
//低配車
class LowCarFactory implements CarFactory {
@Override
public Engine createEngine() {
return new LowEngine();
}
@Override
public Seat createSeat() {
return new LowSeat();
}
}
//高配車
class LuxuryCarFactory implements CarFactory {
@Override
public Engine createEngine() {
return new LuxuryEngine();
}
@Override
public Seat createSeat() {
return new LuxurySeat();
}
}
//配件
class LuxuryEngine implements Engine{
@Override
public void run() {
System.out.println("轉的快！");
}
@Override
public void start() {
System.out.println("啓動快!可以自動啓停！");
}
}
class LowEngine implements Engine{
@Override
public void run() {
System.out.println("轉的慢！");
}
@Override
public void start() {
System.out.println("啓動慢!");
}
}
class LuxurySeat implements Seat {
@Override
public void massage() {
System.out.println("可以自動按摩！");
}
}
class LowSeat implements Seat {
@Override
public void massage() {
System.out.println("不能按摩！");
}
}
public class AbstractFactory {
public static void main(String[] args) {
CarFactory factory = new LuxuryCarFactory();
Engine e = factory.createEngine();
e.run();
e.start();
}
}
在工廠模式中彌補了簡單工廠模式的缺陷（不符合開閉原則），而在抽象工廠模式中彌補了工廠模式的不足（一個工廠只能生產一種產品）。
優點：
- 1、抽象工廠模式隔離了具體類的生產，使得客戶並不需要知道什麼被創建。
- 2、當一個產品族中的多個對象被設計成一起工作時，它能保證客戶端始終只使用同一個產品族中的對象。
- 3、增加新的具體工廠和產品族很方便，無須修改已有系統，符合“開閉原則”。
缺點：
- 增加新的產品等級結構很複雜，需要修改抽象工廠和所有的具體工廠類，對“開閉原則”的支持呈現傾斜性。