盒子
盒子
文章目录
  1. 1. 工厂方法
  2. 2. 抽象工厂
  3. 3. 简单工厂

工厂模式与抽象工厂

工厂方法模式:定义了一个创建对象的接口,但由子类决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类。
抽象工厂模式:提供了一个接口,用于创建相关或依赖对象的家族,而不需要明确指定具体类。

1. 工厂方法

1
2
3
4
5
6
7
8
9
10
11
12
public abstract class PizzaStore {
public Pizza orderPizza(String type) {
Pizza pizza = createPizza(type); //开分店的奥,每个分店需要不同的口味的幺
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
return pizza;
}

protected abstract Pizza createPizza(String type);
}
1
2
3
4
5
6
7
8
9
10
11
12
public class NYPizzaStore extends PizzaStore {
@Override
protected Pizza createPizza(String item) {
if (item.equals("cheese")) {
return new NYStyleCheesePizza();
}
if (item.equals("veggie")) {
return new NYStyleVeggiePizza();
}
return null;
}
}

2. 抽象工厂

1
2
3
4
public interface PizzaIngredientFactory {
Cheese createCheese();
Clam createClam();
}
1
2
3
4
5
6
7
8
9
10
11
12
public class NYPizzaIngredientFactory implements PizzaIngredientFactory {

@Override
public Cheese createCheese() {
return new ReggianoCheese();
}

@Override
public Clam createClam() {
return new FreshClam();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
public class CheesePizza extends Pizza {
private PizzaIngredientFactory ingredientFactory;

public CheesePizza(PizzaIngredientFactory ingredientFactory) {
this.ingredientFactory = ingredientFactory;
}

@Override
public void prepare() {
System.out.println("Preparing " + name);
cheese = ingredientFactory.createCheese();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class NYPizzaStore extends PizzaStore {
@Override
public Pizza createPizza(String item) {
Pizza pizza = null;
PizzaIngredientFactory ingredientFactory = new NYPizzaIngredientFactory();
if (item.equals("cheese")) {
pizza = new CheesePizza(ingredientFactory);
pizza.setName("New York Style Cheese Pizza");
} else if (item.equals("clam")) {
pizza = new ClamPizza(ingredientFactory);
pizza.setName("New York Style Clam Pizza");
}
return pizza;
}
}

3. 简单工厂

1
2
3
4
5
6
7
8
9
10
11
public class SimplePizzaFactory {
public static Pizza createPizza(String type) {
Pizza pizza = null;
if (type.equals("cheese")) {
pizza = new CheesePizza();
} else if (type.equals("veggie")) {
pizza = new VeggiePizza();
}
return pizza;
}
}

抽象工厂与工厂方法区别:

抽象工厂的方法经常以工厂方法的方式实现。抽象工厂的任务是负责创建一组产品的接口,这个接口中的每个方法负责创建一个具体的产品,同时我们利用实现抽象工厂的子类来实现这些具体的做法,所以,在抽象工厂中利用工厂方法实现生产方法是相当自然的事情;
工厂方法创建对象通过继承,抽象工厂通过组合;
扩展新产品抽象工厂接口要改变,工厂方法不需要改变;
抽象工厂用于创建产品家族,让创建的相关产品集合起来,工厂方法使客户代码从实例化的具体类解耦,使用简单

体现设计原则: 依赖倒置原则(依赖于抽象,而非具体类)

备注: 简单工厂不是一种设计模式,反而更像一种编程习惯

支持一下
扫一扫,支持沈健
  • 微信扫一扫
  • 支付宝扫一扫