设计模式-三大工厂

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

简单工厂

一个工厂创建所有具体产品。对于增加新的产品，主要是新增产品，就要修改工厂类。符合单一职责原则。不符合开放-封闭原则

// 假设 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 {
    @Override
    public Animal createAnimal() {
        return new Cat();
    }
}

// 老虎工厂实现
class TigerFactory implements AnimalFactory {
    @Override
    public 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 {
    @Override
    public 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 {
    @Override
    public 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.随着业务的不断拓展，可能会造成类实现上的复杂度。