北京网站假设国内搜索网站
工厂模式：比萨店的秘密武器，轻松搞定对象创建！
大家好，今天我们来聊聊设计模式中的工厂模式。如果你曾经为对象的创建感到头疼，或者觉得代码中到处都是 new 关键字，那么工厂模式就是你的救星！本文基于《Head First 设计模式》的工厂模式章节，带你从比萨店的故事中轻松掌握工厂模式的精髓，附上 Java 代码示例，让你彻底理解并爱上它！
1. 简单工厂模式：比萨店的起步
故事背景
小明开了一家比萨店，刚开始只有两种比萨：芝士比萨和素食比萨。每次接到订单，小明都会根据客户的需求，手动创建对应的比萨对象。
问题出现
随着生意越来越好，比萨的种类也越来越多。小明发现，每次新增一种比萨，都需要修改订单处理的代码。这不仅麻烦，还容易出错。
解决方案：简单工厂模式
小明决定引入简单工厂模式，将比萨的创建逻辑集中到一个工厂类中。这样，无论比萨种类如何变化，订单处理的代码都不需要修改。
代码实现
// 比萨接口
interface Pizza {void prepare();void bake();
}// 具体比萨：芝士比萨
class CheesePizza implements Pizza {@Overridepublic void prepare() {System.out.println("Preparing Cheese Pizza");}@Overridepublic void bake() {System.out.println("Baking Cheese Pizza");}
}// 具体比萨：素食比萨
class VeggiePizza implements Pizza {@Overridepublic void prepare() {System.out.println("Preparing Veggie Pizza");}@Overridepublic void bake() {System.out.println("Baking Veggie Pizza");}
}// 简单工厂
class SimplePizzaFactory {public Pizza createPizza(String pizzaType) {if (pizzaType.equals("cheese")) {return new CheesePizza();} else if (pizzaType.equals("veggie")) {return new VeggiePizza();} else {throw new IllegalArgumentException("Unknown pizza type");}}
}// 客户端代码
public class PizzaStore {public static void main(String[] args) {SimplePizzaFactory factory = new SimplePizzaFactory();Pizza pizza = factory.createPizza("cheese");pizza.prepare(); // 输出: Preparing Cheese Pizzapizza.bake(); // 输出: Baking Cheese Pizza}
}
优点
- 将对象的创建逻辑集中在一个类中，便于维护。
- 客户端与具体产品解耦。
缺点
- 违反“开闭原则”，新增产品时需要修改工厂类。
2. 工厂方法模式：扩展比萨帝国
故事背景
小明的比萨店越做越大，他决定开分店！每个分店都有自己的特色比萨，比如纽约风味芝士比萨和芝加哥风味素食比萨。
问题出现
如果继续使用简单工厂模式，每次新增分店都需要修改工厂类，这显然不够灵活。
解决方案：工厂方法模式
小明决定采用工厂方法模式，将比萨的创建延迟到子类。每个分店都可以实现自己的比萨创建逻辑。
代码实现
// 比萨接口
interface Pizza {void prepare();void bake();
}// 具体比萨：纽约风味芝士比萨
class NYCheesePizza implements Pizza {@Overridepublic void prepare() {System.out.println("Preparing NY Style Cheese Pizza");}@Overridepublic void bake() {System.out.println("Baking NY Style Cheese Pizza");}
}// 具体比萨：芝加哥风味素食比萨
class ChicagoVeggiePizza implements Pizza {@Overridepublic void prepare() {System.out.println("Preparing Chicago Style Veggie Pizza");}@Overridepublic void bake() {System.out.println("Baking Chicago Style Veggie Pizza");}
}// 工厂接口
abstract class PizzaStore {public Pizza orderPizza(String type) {Pizza pizza = createPizza(type);pizza.prepare();pizza.bake();return pizza;}// 工厂方法protected abstract Pizza createPizza(String type);
}// 具体工厂：纽约比萨店
class NYPizzaStore extends PizzaStore {@Overrideprotected Pizza createPizza(String type) {if (type.equals("cheese")) {return new NYCheesePizza();} else {throw new IllegalArgumentException("Unknown pizza type");}}
}// 具体工厂：芝加哥比萨店
class ChicagoPizzaStore extends PizzaStore {@Overrideprotected Pizza createPizza(String type) {if (type.equals("veggie")) {return new ChicagoVeggiePizza();} else {throw new IllegalArgumentException("Unknown pizza type");}}
}// 客户端代码
public class PizzaTest {public static void main(String[] args) {PizzaStore nyStore = new NYPizzaStore();Pizza pizza = nyStore.orderPizza("cheese"); // 输出: Preparing NY Style Cheese Pizza, Baking NY Style Cheese PizzaPizzaStore chicagoStore = new ChicagoPizzaStore();pizza = chicagoStore.orderPizza("veggie"); // 输出: Preparing Chicago Style Veggie Pizza, Baking Chicago Style Veggie Pizza}
}
优点
- 符合“开闭原则”，新增产品时只需扩展子类。
- 将对象的创建逻辑分散到子类，降低了耦合度。
缺点
- 类的数量会增加，系统复杂度提高。
3. 抽象工厂模式：比萨与饮料的完美搭配
故事背景
小明发现，客户不仅喜欢比萨，还喜欢搭配饮料。于是，他决定推出套餐，每个套餐包含一款比萨和一款饮料。
问题出现
如果使用工厂方法模式，比萨和饮料的创建逻辑会分散在不同的工厂中，难以保证它们之间的兼容性。
解决方案：抽象工厂模式
小明决定采用抽象工厂模式，将比萨和饮料的创建逻辑集中到一个工厂中，确保每个套餐的比萨和饮料是兼容的。
代码实现
// 比萨接口
interface Pizza {void prepare();
}// 饮料接口
interface Drink {void serve();
}// 具体比萨：纽约风味芝士比萨
class NYCheesePizza implements Pizza {@Overridepublic void prepare() {System.out.println("Preparing NY Style Cheese Pizza");}
}// 具体饮料：纽约风味可乐
class NYCoke implements Drink {@Overridepublic void serve() {System.out.println("Serving NY Style Coke");}
}// 具体比萨：芝加哥风味素食比萨
class ChicagoVeggiePizza implements Pizza {@Overridepublic void prepare() {System.out.println("Preparing Chicago Style Veggie Pizza");}
}// 具体饮料：芝加哥风味雪碧
class ChicagoSprite implements Drink {@Overridepublic void serve() {System.out.println("Serving Chicago Style Sprite");}
}// 抽象工厂接口
interface MealFactory {Pizza createPizza();Drink createDrink();
}// 具体工厂：纽约风味套餐
class NYMealFactory implements MealFactory {@Overridepublic Pizza createPizza() {return new NYCheesePizza();}@Overridepublic Drink createDrink() {return new NYCoke();}
}// 具体工厂：芝加哥风味套餐
class ChicagoMealFactory implements MealFactory {@Overridepublic Pizza createPizza() {return new ChicagoVeggiePizza();}@Overridepublic Drink createDrink() {return new ChicagoSprite();}
}// 客户端代码
public class MealTest {public static void main(String[] args) {MealFactory nyFactory = new NYMealFactory();Pizza pizza = nyFactory.createPizza();Drink drink = nyFactory.createDrink();pizza.prepare(); // 输出: Preparing NY Style Cheese Pizzadrink.serve(); // 输出: Serving NY Style CokeMealFactory chicagoFactory = new ChicagoMealFactory();pizza = chicagoFactory.createPizza();drink = chicagoFactory.createDrink();pizza.prepare(); // 输出: Preparing Chicago Style Veggie Pizzadrink.serve(); // 输出: Serving Chicago Style Sprite}
}
优点
- 可以创建一组相关的对象，保证它们之间的兼容性。
- 符合“开闭原则”，新增产品族时只需扩展工厂类。
缺点
- 类的数量会大幅增加，系统复杂度提高。
总结
工厂模式的核心思想是将对象的创建与使用分离，从而使得系统更加灵活和可维护。三种工厂模式各有优缺点：
- 简单工厂模式：适合创建逻辑简单的场景，但违反“开闭原则”。
- 工厂方法模式：通过子类实现对象的创建，符合“开闭原则”，但会增加类的数量。
- 抽象工厂模式：适合创建一组相关对象的场景，但系统复杂度较高。
在实际开发中，应根据具体需求选择合适的工厂模式，以达到代码的高内聚、低耦合。希望本文能帮助你更好地理解工厂模式，并在项目中灵活运用！
互动话题
你在项目中用过工厂模式吗？遇到过哪些问题？欢迎在评论区分享你的经验！