设计模式-三大工厂

工厂模式有三种，分别是简单工厂模式、工厂方法模式、抽象工厂模式。三种模式从前到后越来越抽象，也更具有一般性。

设计模式	优点	缺点
简单工厂	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.随着业务的不断拓展，可能会造成类实现上的复杂度。