工厂模式是一种创建模式，它定义了用于创建对象的接口，但让子类决定要实例化哪个类。工厂模式让类将实例化推迟到子类。
当您具有“产品”继承层次结构并可能向其中添加其他产品时，请使用工厂模式。 （Product指的是Factory方法返回的对象）
如果你不了解 Simple Factory，我建议你先学习一下。资源很多，但我的博客在这里。
之前，我们引入了简单工厂，我们可以生产各种汉堡，同时将对象创建与客户端代码解耦。我们的汉堡店已经成功盈利，现在我们想在不同的地区开设其他汉堡店。
orderBurger 方法定义了向客户销售汉堡的流程。
// This is our Client
public class BurgerShop {
public Burger orderBurger(BurgerType type) {
// Factory is responsible for object creation
Burger burger = SimpleBurgerFactory.createBurger(type);
burger.prepareBun();
burger.grillPatty();
burger.addToppings();
burger.wrap();
return burger;
}
}
这完全没问题，但是如果我们开其他汉堡店怎么办？假设我们启动“SeaSideBurgerShop”，我们将创建 SeaSideBurgerShop 类并定义它自己的 orderBurger()。问题是，他们可能会忘记添加配料或以错误的顺序进行操作。
有问题的海边汉堡店：
public class SeaSideBurgerShop {
public Burger orderBurger(BurgerType type) {
Burger burger = SimpleBurgerFactory.createBurger(type);
burger.prepareBun();
burger.wrap(); // Wrap a burger before grilling a patty??
burger.grillPatty();
// They forget to add toppings!!
return burger;
}
}
为了防止这种情况发生，我们的汉堡店需要一个框架，定义他们执行流程的顺序以及要做什么，但仍然允许事情保持灵活性。
汉堡店
这个抽象类有两个方法：orderBurger() 和 createBurger()。 orderBurger() 定义要做什么以及该过程应按什么顺序完成。这可以防止汉堡店忘记某些流程或弄乱流程顺序。 creatBurger() 是抽象方法，让子类决定制作哪种汉堡。
BurgerShop 子类
这些具体的汉堡店负责制作具体的汉堡。每个扩展 BurgerShop 的子类都定义了自己的 createBurger() 实现。
汉堡
这个抽象类提供所有汉堡之间的通用接口并定义默认行为。
汉堡子类
这是我们的具体产品。只要扩展 Burger 类，他们就可以通过重写方法来实现特定行为。
// This is our Client
public class BurgerShop {
public Burger orderBurger(BurgerType type) {
// Factory is responsible for object creation
Burger burger = SimpleBurgerFactory.createBurger(type);
burger.prepareBun();
burger.grillPatty();
burger.addToppings();
burger.wrap();
return burger;
}
}
public class SeaSideBurgerShop {
public Burger orderBurger(BurgerType type) {
Burger burger = SimpleBurgerFactory.createBurger(type);
burger.prepareBun();
burger.wrap(); // Wrap a burger before grilling a patty??
burger.grillPatty();
// They forget to add toppings!!
return burger;
}
}
public enum BurgerType {
BEEF,
CHICKEN,
FISH,
VEGGIE
}
public abstract class Burger {
public BurgerType type;
public List<String> toppings = new ArrayList<>();
public void prepareBun() {
System.out.println("Preparing a bun");
}
public void grillPatty() {
if (type == null) {
throw new IllegalStateException("pattyType is undefined");
}
System.out.println("Grill a " + type + " patty");
}
public void addToppings() {
for (String item : toppings) {
System.out.println("Add " + item);
}
}
public void wrap() {
System.out.println("Wrap a burger up");
}
}
public class CityStyleBeefBurger extends Burger {
public CityStyleBeefBurger() {
type = BurgerType.BEEF;
List<String> items = List.of("lettuce", "pickle slices", "tomato slice", "BBQ sauce");
toppings.addAll(items);
}
}
public class CityStyleVeggieBurger extends Burger {
public CityStyleVeggieBurger() {
type = BurgerType.VEGGIE;
List<String> items = List.of("smoked paprika", "garlic chips", "crushed walnuts", "veggie sauce");
toppings.addAll(items);
}
}
public class SeaSideStyleBeefBurger extends Burger {
public SeaSideStyleBeefBurger() {
type = BurgerType.BEEF;
// Localized toppings for beef burger in seaside area
List<String> items = List.of("lettuce", "pickle slices", "tomato slice", "salty sauce");
toppings.addAll(items);
}
// Uses localized wrapping paper
@Override
public void wrap() {
System.out.println("Wrap with a paper with nice sea scenery");
}
}
public class SeaSideStyleFishBurger extends Burger {
public SeaSideStyleFishBurger() {
type = BurgerType.FISH;
// Localized toppings for fish burger in seaside area
List<String> items = List.of("red onion slices", "salty sauce", "fried shrimps");
toppings.addAll(items);
}
// Uses localized wrapping paper
@Override
public void wrap() {
System.out.println("Wrap with a paper with nice sea scenery");
}
}
public abstract class BurgerShop {
// This method provides a framework for each burger shops to order burgers
public Burger orderBurger(BurgerType type) {
Burger burger = createBurger(type);
burger.prepareBun();
burger.grillPatty();
burger.addToppings();
burger.wrap();
return burger;
}
// This is our factory method. Subclasses will override this method,
// provide their own implementation, determine which kind of burger gets made.
public abstract Burger createBurger(BurgerType type);
}
输出：
public class CityBurgerShop extends BurgerShop {
@Override
public Burger createBurger(BurgerType type) {
return switch (type) {
case BEEF -> new CityStyleBeefBurger();
case VEGGIE -> new CityStyleVeggieBurger();
default -> throw new IllegalArgumentException("unknown city burger type");
};
}
}
您可以在这里查看所有设计模式的实现。
GitHub 存储库
附注
我是刚开始写科技博客，如果您对我的写作有什么建议，或者有任何困惑的地方，请留言！
感谢您的阅读:)
以上是工厂模式的详细内容。更多信息请关注PHP中文网其他相关文章！
