设计模式之工厂方法模式

1. 核心思想

工厂方法模式（Factory Method Pattern）将对象的创建过程延迟到子类。具体来说，定义一个创建对象的接口（抽象工厂），但由子类决定实例化哪个具体类。这种方式解耦了对象的创建和使用，使系统更灵活、可扩展。
用大白话来说就是对象的接口就是USB接口，你要使用什么设备只要他是USB口的都可以接上去进行基本的使用。

2. 模式结构

比如说抽象产品是油炸类，具体的产品就可以是炸豆腐，抽象工厂就可以是生产油炸食品，具体工厂就是生产炸豆腐工厂

3. 代码示例

PHP代码

<?php 
// 抽象产品 
abstract class Animal { 
    abstract public function speak(); 
} 
 
// 具体产品 
class Dog extends Animal { 
    public function speak() { 
        return "汪汪！"; 
    } 
} 
 
class Cat extends Animal { 
    public function speak() { 
        return "喵喵！"; 
    } 
} 
 
// 抽象工厂 
abstract class AnimalFactory { 
    abstract public function create_animal(); 
} 
 
// 具体工厂 
class DogFactory extends AnimalFactory { 
    public function create_animal() { 
        return new Dog(); 
    } 
} 
 
class CatFactory extends AnimalFactory { 
    public function create_animal() { 
        return new Cat(); 
    } 
} 
 
// 客户端使用 
$dog_factory = new DogFactory(); 
$dog = $dog_factory->create_animal(); 
echo $dog->speak(); // 输出：汪汪！ 
echo "<br>"; 
 
$cat_factory = new CatFactory(); 
$cat = $cat_factory->create_animal(); 
echo $cat->speak(); // 输出：喵喵！ 
?> 

python代码

# 抽象产品
class Animal:
    def speak(self):
        pass

# 具体产品
class Dog(Animal):
    def speak(self):
        return "汪汪！"

class Cat(Animal):
    def speak(self):
        return "喵喵！"

# 抽象工厂
class AnimalFactory:
    def create_animal(self):
        pass

# 具体工厂
class DogFactory(AnimalFactory):
    def create_animal(self):
        return Dog()

class CatFactory(AnimalFactory):
    def create_animal(self):
        return Cat()

# 客户端使用
dog_factory = DogFactory()
dog = dog_factory.create_animal()
print(dog.speak())  # 输出：汪汪！

cat_factory = CatFactory()
cat = cat_factory.create_animal()
print(cat.speak())  # 输出：喵喵！

Java代码

// 抽象产品 
abstract class Animal { 
    public abstract String speak(); 
} 
 
// 具体产品：狗 
class Dog extends Animal { 
    @Override 
    public String speak() { 
        return "汪汪！"; 
    } 
} 
 
// 具体产品：猫 
class Cat extends Animal { 
    @Override 
    public String speak() { 
        return "喵喵！"; 
    } 
} 
 
// 抽象工厂 
abstract class AnimalFactory { 
    public abstract Animal create_animal(); 
} 
 
// 具体工厂：狗工厂 
class DogFactory extends AnimalFactory { 
    @Override 
    public Animal create_animal() { 
        return new Dog(); 
    } 
} 
 
// 具体工厂：猫工厂 
class CatFactory extends AnimalFactory { 
    @Override 
    public Animal create_animal() { 
        return new Cat(); 
    } 
} 
 
// 客户端使用 
public class Main { 
    public static void main(String[] args) { 
        AnimalFactory dogFactory = new DogFactory(); 
        Animal dog = dogFactory.create_animal();  
        System.out.println(dog.speak());   // 输出：汪汪！ 
 
        AnimalFactory catFactory = new CatFactory(); 
        Animal cat = catFactory.create_animal();  
        System.out.println(cat.speak());   // 输出：喵喵！ 
    } 
} 

4. 应用场景

需要动态扩展产品类型：例如新增一种动物（如Bird），只需添加Bird类和BirdFactory类，无需修改现有代码。
系统需要解耦：客户端只需依赖抽象接口（Animal和AnimalFactory），不关心具体实现。

5. 优缺点对比

6. 对比简单工厂模式

简单工厂：一个工厂类集中创建所有产品（如AnimalFactory.create(“Dog”)），违反开闭原则。
工厂方法：每个产品对应一个工厂类，扩展时只需新增类，无需修改原有代码。

思维导图