题目
介绍下工厂模式
解释
简单工厂模式、工厂方法模式、抽象工厂模式
答案
工厂模式提供了一种创建对象的方式，而无需指定要创建的具体类。
通过使用工厂模式，可以将对象的创建逻辑封装在一个工厂类中，而不是在客户端代码中直接实例化对象，这样可以提高代码的可维护性和可扩展性。
## 工厂模式的类型
### 简单工厂模式（Simple Factory Pattern）
简单工厂模式不是一个正式的设计模式，但它是工厂模式的基础。它使用一个单独的工厂类来创建不同的对象，根据传入的参数决定创建哪种类型的对象，客户端无需关注具体类名。
工厂类集中管理对象的创建逻辑，但新增产品需修改工厂类代码，违反开闭原则。
代码示例:
```java
// 抽象产品接口
interface Device {
void start();
}
// 具体产品类
class Phone implements Device {
@Override
public void start() { System.out.println("手机开机"); }
}
class Tablet implements Device {
@Override
public void start() { System.out.println("平板开机"); }
}
// 简单工厂类
class SimpleDeviceFactory {
public static Device createDevice(String type) {
if ("phone".equals(type)) {
return new Phone();
} else if ("tablet".equals(type)) {
return new Tablet();
}
throw new IllegalArgumentException("未知设备类型");
}
}
// 客户端使用
public class Client {
public static void main(String[] args) {
Device device = SimpleDeviceFactory.createDevice("phone");
device.start(); // 输出：手机开机
}
}
```
### 工厂方法模式（Factory Method Pattern）
工厂方法模式定义了一个创建对象的接口，但由子类决定实例化哪个类。工厂方法将对象的创建延迟到子类。每个产品对应一个工厂类，符合开闭原则，但类数量增加
代码示例:
```java
// 抽象产品接口
interface LoginService {
boolean login(String username, String credential);
}
// 具体产品类
class UserLoginService implements LoginService {
@Override
public boolean login(String username, String password) {
System.out.println("普通用户登录验证");
return "user".equals(username) && "123".equals(password);
}
}
// 抽象工厂接口
interface LoginFactory {
LoginService createLoginService();
}
// 具体工厂类
class UserLoginFactory implements LoginFactory {
@Override
public LoginService createLoginService() {
return new UserLoginService();
}
}
// 客户端使用
public class Client {
public static void main(String[] args) {
LoginFactory factory = new UserLoginFactory();
LoginService service = factory.createLoginService();
service.login("user", "123");
}
}
```
### 抽象工厂模式（Abstract Factory Pattern）
抽象工厂模式提供接口创建多个相关产品族（如Apple全家桶：手机+充电器），确保产品兼容性。适用于需要统一产品族的场景，但新增产品种类困难
代码示例:
```java
// 抽象产品族
interface Phone {
void use();
}
interface Charger {
void charge();
}
// Apple产品族
class iPhone implements Phone {
@Override
public void use() { System.out.println("使用iPhone"); }
}
class AppleCharger implements Charger {
@Override
public void charge() { System.out.println("Apple充电器工作"); }
}
// 抽象工厂接口
interface TechFactory {
Phone createPhone();
Charger createCharger();
}
// 具体工厂类
class AppleFactory implements TechFactory {
@Override
public Phone createPhone() { return new iPhone(); }
@Override
public Charger createCharger() { return new AppleCharger(); }
}
// 客户端使用
public class Client {
public static void main(String[] args) {
TechFactory factory = new AppleFactory();
Phone phone = factory.createPhone();
Charger charger = factory.createCharger();
phone.use();
charger.charge();
}
}
```
## 总结
- **简单工厂**：适用于产品少且变化不频繁的场景，快速实现但扩展性差
- **工厂方法**：适合需要灵活扩展单一产品的场景，如多品牌设备生产
- **抽象工厂**：用于管理多个相关产品族，如跨平台应用开发