简单工厂模式
一个具体需求： 披萨订购
- 披萨有很多种类（ChinesePizza，CheesePizza）
- 披萨有各自的制作流程（cut，bake，box）
传统实现方式
1.抽象pizza类
package 工厂模式.pizza;
//将Pizza 类做成抽象
public abstract class Pizza {
protected String name; //名字
//准备原材料, 不同的披萨不一样，因此，我们做成抽象方法
public abstract void prepare();
public void bake() {
System.out.println(name + " baking;");
}
public void cut() {
System.out.println(name + " cutting;");
}
//打包
public void box() {
System.out.println(name + " boxing;");
}
public void setName(String name) {
this.name = name;
}
}
2.三个具体pizza类
package 工厂模式.pizza;
public class PepperPizza extends Pizza {
@Override
public void prepare() {
// TODO Auto-generated method stub
System.out.println(" 给胡椒披萨准备原材料 ");
}
}
package 工厂模式.pizza;
public class GreekPizza extends Pizza {
@Override
public void prepare() {
// TODO Auto-generated method stub
System.out.println(" 给希腊披萨 准备原材料 ");
}
}
package 工厂模式.pizza;
public class CheesePizza extends Pizza {
@Override
public void prepare() {
// TODO Auto-generated method stub
System.out.println(" 给制作奶酪披萨 准备原材料 ");
}
}
3.订购pizza的方法
public class OrderPizza {
// 构造器
public OrderPizza() {
Pizza pizza = null;
String orderType; // 订购披萨的类型
do {
orderType = getType();
if (orderType.equals("greek")) {
pizza = new GreekPizza();
pizza.setName(" 希腊披萨 ");
} else if (orderType.equals("cheese")) {
pizza = new CheesePizza();
pizza.setName(" 奶酪披萨 ");
} else if (orderType.equals("pepper")) {
pizza = new PepperPizza();
pizza.setName("胡椒披萨");
} else {
break;
}
//输出pizza 制作过程
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
} while (true);
}
// 写一个方法，可以获取客户希望订购的披萨种类
private String getType() {
try {
BufferedReader string = new BufferedReader(new InputStreamReader(System.in));
System.out.println("input pizza 种类:");
String str = string.readLine();
return str;
} catch (IOException e) {
e.printStackTrace();
return "";
}
}
}
缺点： 易理解但是违反了开闭原则即对修改关闭对扩展开放
改进思路： 把创建Pizza对象封装到一个类中，当出现新品pizza时，只需要修改该类即可。
简单工厂模式的实现
简单工厂模式介绍
- 简单工厂模式属于创建者模式，是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建出哪一种产品的实例
- 简单工厂模式定义了一个创建对象的类，由这个类封装实例化对象的行为
- 一般实际开发中当大量创建某类对象时会使用工厂模式
实现代码
1.新写一个工厂类
/简单工厂类
public class SimpleFactory {
//简单工厂模式 也叫 静态工厂模式
public static Pizza createPizza(String orderType) {
Pizza pizza = null;
System.out.println("使用简单工厂模式");
if (orderType.equals("greek")) {
pizza = new GreekPizza();
pizza.setName(" 希腊披萨 ");
} else if (orderType.equals("cheese")) {
pizza = new CheesePizza();
pizza.setName(" 奶酪披萨 ");
} else if (orderType.equals("pepper")) {
pizza = new PepperPizza();
pizza.setName("胡椒披萨");
}
return pizza;
}
}
2.重写订购pizza类
public class OrderPizza {
Pizza pizza = null;
String orderType = "";
// 构造器
public OrderPizza() {
do {
orderType = getType();
pizza = SimpleFactory.createPizza(orderType);
// 输出pizza
if (pizza != null) { // 订购成功
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
} else {
System.out.println(" 订购披萨失败 ");
break;
}
} while (true);
}
// 写一个方法，可以获取客户希望订购的披萨种类
private String getType() {
try {
BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
System.out.println("input pizza 种类:");
String str = strin.readLine();
return str;
} catch (IOException e) {
e.printStackTrace();
return "";
}
}
}
工厂方法模式
一个新需求：
对于pizza又细分为北京的xx披萨，伦敦的xx披萨等
解决思路一：
使用简单工厂模式创建多个工厂如北京工厂，伦敦工厂等。但是有缺点不易扩展不易维护
解决方案二：
使用工厂方法模式
工厂方法模式的介绍
定义一个创建对象的抽象方法，由子类决定要实例化的类。工厂方法模式将对象的实例化推迟到子类
代码
1.OrderPizza抽象类
public abstract class OrderPizza {
//定义一个抽象方法，createPizza , 让各个工厂子类自己实现
abstract Pizza createPizza(String orderType);
// 构造器
public OrderPizza() {
Pizza pizza = null;
String orderType; // 订购披萨的类型
do {
orderType = getType();
pizza = createPizza(orderType); //抽象方法，由工厂子类完成
//输出pizza 制作过程
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
} while (true);
}
// 写一个方法，可以获取客户希望订购的披萨种类
private String getType() {
try {
BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
System.out.println("input pizza 种类:");
String str = strin.readLine();
return str;
} catch (IOException e) {
e.printStackTrace();
return "";
}
}
}
2.两个工厂子类
public class LDOrderPizza extends OrderPizza {
@Override
Pizza createPizza(String orderType) {
Pizza pizza = null;
if(orderType.equals("cheese")) {
pizza = new LDCheesePizza();
} else if (orderType.equals("pepper")) {
pizza = new LDPepperPizza();
}
// TODO Auto-generated method stub
return pizza;
}
}
public class BJOrderPizza extends OrderPizza {
@Override
Pizza createPizza(String orderType) {
Pizza pizza = null;
if(orderType.equals("cheese")) {
pizza = new BJCheesePizza();
} else if (orderType.equals("pepper")) {
pizza = new BJPepperPizza();
}
// TODO Auto-generated method stub
return pizza;
}
}
抽象工厂模式
基本介绍
- 定义一个接口用于创建相关或有依赖关系的对象簇而无需指明具体的类
- 抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合
- 从设计层面上来看，抽象工厂模式就是对简单工厂模式的进一步抽象
- 将工厂抽象成两层，抽象工厂和具体实现的工厂子类，这样可以根据创建对象类型使用对应的工厂子类，这样讲单个简单工厂变成工厂簇易于维护
代码
1.抽象层
//一个抽象工厂模式的抽象层(接口)
public interface AbsFactory {
//让下面的工厂子类来 具体实现
public Pizza createPizza(String orderType);
}
2.工厂子类
//这是工厂子类
public class BJFactory implements AbsFactory {
@Override
public Pizza createPizza(String orderType) {
System.out.println("~使用的是抽象工厂模式~");
// TODO Auto-generated method stub
Pizza pizza = null;
if(orderType.equals("cheese")) {
pizza = new BJCheesePizza();
} else if (orderType.equals("pepper")){
pizza = new BJPepperPizza();
}
return pizza;
}
}
public class LDFactory implements AbsFactory {
@Override
public Pizza createPizza(String orderType) {
System.out.println("~使用的是抽象工厂模式~");
Pizza pizza = null;
if (orderType.equals("cheese")) {
pizza = new LDCheesePizza();
} else if (orderType.equals("pepper")) {
pizza = new LDPepperPizza();
}
return pizza;
}
}
3.调用不同工厂的类
public class OrderPizza {
AbsFactory factory;
// 构造器
public OrderPizza(AbsFactory factory) {
setFactory(factory);
}
private void setFactory(AbsFactory factory) {
Pizza pizza = null;
String orderType = ""; // 用户输入
this.factory = factory;
do {
orderType = getType();
// factory 可能是北京的工厂子类，也可能是伦敦的工厂子类
pizza = factory.createPizza(orderType);
if (pizza != null) { // 订购ok
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
} else {
System.out.println("订购失败");
break;
}
} while (true);
}
// 写一个方法，可以获取客户希望订购的披萨种类
private String getType() {
try {
BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
System.out.println("input pizza 种类:");
String str = strin.readLine();
return str;
} catch (IOException e) {
e.printStackTrace();
return "";
}
}
}
4.最终使用
public class PizzaStore {
public static void main(String[] args) {
// TODO Auto-generated method stub
//new OrderPizza(new BJFactory());
new OrderPizza(new LDFactory());
}
}
工厂模式的应用和小结
应用： Calendar cal = Calendar.getInstance();
小结：
- 工厂模式的意义在于将实例化对象代码块提取出来，放到一个类中统一管理和维护
- 三种工厂模式，简单工厂模式->工厂方法模式->抽象工厂模式的主要变化在于一步步添加抽象层而已。
实际项目的参考意义
- 创建对象时不要直接new对象而是把对象的创建放到一个工厂中去
- 不要让类继承具体类而是让其继承抽象方法或者实现接口
- 不要覆盖基类中已经实现的方法
扫一扫
253
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
