工廠模式有三種，分別是簡單工廠模式、工廠方法模式、抽象工廠模式。三種模式從前到后越來越抽象，也更具有一般性。

設計模式	優點	缺點
簡單工廠	1.實現了對責任的分割，它提供了專門的工廠類用于創建對象。	1.違背了開閉原則。 2.使用了靜態工廠方法，靜態方法不能被繼承和重寫。
工廠方法	1.避免創建者與具體的產品邏輯耦合 。 2.滿?單?職責，每?個業務邏輯實現都在所屬??的類中完成 。 3.滿?開閉原則，?需更改使?調??就可以在程序中引?新的產品類型	1.如果存在非常多的產品類型，實現的子類就會極速擴張。
抽象工廠	1.滿足了單一職責、開閉原則、解耦等優點。	1.隨著業務的不斷拓展，可能會造成類實現上的復雜度。

簡單工廠

一個工廠創建所有具體產品。對于增加新的產品，主要是新增產品，就要修改工廠類。符合單一職責原則。不符合開放-封閉原則

// 假設 Animal 是一個接口或抽象類
// Tiger 和 Cat 是實現了 Animal 接口的類// 定義 Animal 接口/抽象類
interface Animal {// 動物通用的方法（如果需要）
}// 具體的 Tiger 實現
class Tiger implements Animal {// 老虎的具體實現
}// 具體的 Cat 實現
class Cat implements Animal {// 貓的具體實現
}class AnimalFactory {// 定義 AnimalType 枚舉public enum AnimalType {TIGER, // 老虎類型CAT    // 貓類型}// 靜態方法，用于創建動物public static Animal createAnimal(AnimalType type) {if (AnimalType.TIGER == type) {return new Tiger(); // 如果是老虎類型，則創建 Tiger 對象} else if (AnimalType.CAT == type) {return new Cat();   // 如果是貓類型，則創建 Cat 對象}return null; // 如果類型不匹配，則返回 null (或者可以拋出 IllegalArgumentException 異常)}// 示例用法（可選，用于測試）public static void main(String[] args) {// 通過工廠創建老虎Animal tiger = AnimalFactory.createAnimal(AnimalType.TIGER);System.out.println("創建了動物: " + tiger.getClass().getSimpleName());// 通過工廠創建貓Animal cat = AnimalFactory.createAnimal(AnimalType.CAT);System.out.println("創建了動物: " + cat.getClass().getSimpleName());// 嘗試創建未知類型的動物（會返回 null）Animal unknown = AnimalFactory.createAnimal(null); // 傳入 null 僅作演示，實際應用中應避免if (unknown == null) {System.out.println("未知類型的動物無法創建。");}}
}

優點：

1.實現了對責任的分割，它提供了專門的工廠類用于創建對象。

缺點：

1.違背了開閉原則。

2.使用了靜態工廠方法，靜態方法不能被繼承和重寫。

工廠方法

一個工廠方法只創建一個具體產品。支持增加任意產品，新增產品時不需要更改已有的工廠，需要增加該產品對應的工廠。符合單一職責原則、符合開放-封閉原則。但是引入了復雜性。

// 動物基類
abstract class Animal {// 可以在這里定義動物共有的方法和屬性
}// 具體動物類 - 貓
class Cat extends Animal {public Cat() {System.out.println("創建了一只貓");}
}// 具體動物類 - 老虎
class Tiger extends Animal {public Tiger() {System.out.println("創建了一只老虎");}
}// 抽象工廠接口
interface AnimalFactory {Animal createAnimal();
}// 貓工廠實現
class CatFactory implements AnimalFactory {@Overridepublic Animal createAnimal() {return new Cat();}
}// 老虎工廠實現
class TigerFactory implements AnimalFactory {@Overridepublic Animal createAnimal() {return new Tiger();}
}// 使用示例
public class FactoryExample {public static void main(String[] args) {// 創建貓工廠并生產貓AnimalFactory catFactory = new CatFactory();Animal cat = catFactory.createAnimal();  // 輸出: 創建了一只貓// 創建老虎工廠并生產老虎AnimalFactory tigerFactory = new TigerFactory();Animal tiger = tigerFactory.createAnimal();  // 輸出: 創建了一只老虎}
}

優點：

1.避免創建者與具體的產品邏輯耦合 。

2.滿?單?職責，每?個業務邏輯實現都在所屬??的類中完成 。

3.滿?開閉原則，?需更改使?調??就可以在程序中引?新的產品類型

缺點：

1.如果存在非常多的產品類型，實現的子類就會極速擴張。

抽象工廠

一個工廠方法只創建一類具體產品。增加新產品時，需要修改工廠，增加產品族時，需要增加工廠。符合單一職責原則，部分符合開放-封閉原則，降低了復雜性

// 假設 AbsractAnimalFactory 是一個抽象類或接口
// AnimalType 是一個枚舉（TIGER, CAT）
// Animal 是一個接口或抽象類// 定義 Animal 接口/抽象類
interface Animal {// 動物通用的方法（如果需要）
}// SimpleMode 下具體的 Animal 實現
class SimpleModeTiger implements Animal {// SimpleMode 老虎的具體實現
}class SimpleModeCat implements Animal {// SimpleMode 貓的具體實現
}// HardMode 下具體的 Animal 實現
class HardModeTiger implements Animal {// HardMode 老虎的具體實現
}class HardModeCat implements Animal {// HardMode 貓的具體實現
}// 定義 AnimalType 枚舉
enum AnimalType {TIGER, // 老虎類型CAT    // 貓類型
}// 定義抽象工廠 (AbsractAnimalFactory)
abstract class AbsractAnimalFactory {public abstract Animal createAnimal(AnimalType type);
}// SimpleModeAnimalFactory 實現
class SimpleModeAnimalFactory extends AbsractAnimalFactory {@Overridepublic Animal createAnimal(AnimalType type) {if (AnimalType.TIGER == type) {return new SimpleModeTiger(); // 創建 SimpleMode 老虎} else if (AnimalType.CAT == type) {return new SimpleModeCat();   // 創建 SimpleMode 貓}return null; // 或者拋出 IllegalArgumentException 異常}
}// HardModeAnimalFactory 實現
class HardModeAnimalFactory extends AbsractAnimalFactory {@Overridepublic Animal createAnimal(AnimalType type) {if (AnimalType.TIGER == type) {return new HardModeTiger(); // 創建 HardMode 老虎} else if (AnimalType.CAT == type) {return new HardModeCat();   // 創建 HardMode 貓}return null; // 或者拋出 IllegalArgumentException 異常}
}// 示例用法（可選，用于測試）
public class AnimalFactoryDemo {public static void main(String[] args) {// 創建 Simple 模式動物工廠AbsractAnimalFactory simpleFactory = new SimpleModeAnimalFactory();Animal simpleTiger = simpleFactory.createAnimal(AnimalType.TIGER); // 通過 Simple 工廠創建老虎Animal simpleCat = simpleFactory.createAnimal(AnimalType.CAT);     // 通過 Simple 工廠創建貓// 創建 Hard 模式動物工廠AbsractAnimalFactory hardFactory = new HardModeAnimalFactory();Animal hardTiger = hardFactory.createAnimal(AnimalType.TIGER);   // 通過 Hard 工廠創建老虎Animal hardCat = hardFactory.createAnimal(AnimalType.CAT);       // 通過 Hard 工廠創建貓System.out.println("創建了 Simple 模式的老虎: " + simpleTiger.getClass().getSimpleName());System.out.println("創建了 Simple 模式的貓: " + simpleCat.getClass().getSimpleName());System.out.println("創建了 Hard 模式的老虎: " + hardTiger.getClass().getSimpleName());System.out.println("創建了 Hard 模式的貓: " + hardCat.getClass().getSimpleName());}
}

優點：1.滿足了單一職責、開閉原則、解耦等優點。

缺點：1.隨著業務的不斷拓展，可能會造成類實現上的復雜度。