基本需求:
传统方式:
-
实现思路
- 在订购类中根据用户不同的输入直接创建不同的披萨实体类进行返回
-
UML类图
-
代码实现
-
披萨类
-
// 抽象父类
public abstract class Pizza {
String name;
public abstract void prepare();
public void bake() {
System.out.println(this.name + "披萨烘焙中");
}
public void cut() {
System.out.println(this.name + "披萨切割中");
}
public void box() {
System.out.println(this.name + "披萨打包中");
}
}
// 奶酪披萨 子类1
public class CheesePizza extends Pizza {
public CheesePizza(String name) {
this.name = name;
}
@Override
public void prepare() {
System.out.println(this.name + "披萨准备原材料中");
}
}
// 希腊披萨 子类2
public class GreekPizza extends Pizza{
public GreekPizza(String name) {
this.name = name;
}
@Override
public void prepare() {
System.out.println(this.name + "披萨准备原材料中");
}
}
-
订购类
-
public class PizzaStore {
public static void main(String[] args) {
new PizzaStore().OrderPizza();
}
// 订购披萨方法 传统方式直接采用new出子类的方法进行返回对应的披萨
public void OrderPizza() {
Pizza pizza;
Scanner scanner = new Scanner(System.in);
String orderType;
while (true) {
System.out.println("输入披萨的种类:");
orderType = scanner.nextLine();
if (StringUtils.equals("cheese",orderType)) {
pizza = new CheesePizza("cheese");
} else if (StringUtils.equals("greek",orderType)) {
pizza = new GreekPizza("greek");
} else {
System.out.println("没有该类型的披萨");
break;
}
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
}
}
}
缺陷及改进:
- 在订购方法中,直接采用new出子类的方法进行返回对应的披萨,违反了设计模式的ocp原则,即对扩展开放,对修改关闭。即当我们给类增加新功能的时候,尽量不修改代码,或者尽可能少修改代码
- 如果新增加一种类型的披萨,则需要修改OrderPizza的方法实现,如果有多个创建Pizza的方法则都需要修改
- 把创建Pizza对象封装到一个类中,这样我们有新的Pizza种类时,只需要修改该类就可,其它有创建Pizza对象的代码就不需要修改了——>简单工厂模式
简单工厂模式:
-
简单工厂模式是属于创建型模式,是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式
-
简单工厂模式:定义了一个创建对象的类,由这个类来封装实例化对象的行为(代码)
-
当我们会用到大量的创建某种、某类或者某批对象时,就会使用到工厂模式
-
实现思路
- 创建一个简单工厂类SimpleFactory,提供一个创建Pizza的方法,PizzaStore想要Pizza时,直接在工厂中获取即可
-
UML类图
-
代码实现
-
// 简单工厂类 Pizza类及实现类同上
public class SimpleFactory {
// 创建Pizza的方法 可在多个地方调用,如果需要增加其他种类的Pizza则只需要修改此方法内部的实现即可,不需要调用方
public Pizza createPizza(String orderType) {
Pizza pizza = null;
if (StringUtils.equals("cheese",orderType)) {
pizza = new CheesePizza("cheese");
} else if (StringUtils.equals("greek",orderType)) {
pizza = new GreekPizza("greek");
} else {
System.out.println("没有该类型的披萨");
}
return pizza;
}
// 简单工厂也叫静态工厂 可直接提供静态的方法获取对象
public static Pizza createPizza1(String orderType) {
Pizza pizza = null;
if (StringUtils.equals("cheese",orderType)) {
pizza = new GreekPizza("greek");
} else {
System.out.println("没有该类型的披萨");
}
return pizza;
}
}
-
public class PizzaStore {
public static void main(String[] args) {
// new PizzaStore().OrderPizza();
new PizzaStore(new SimpleFactory());
}
private SimpleFactory simpleFactory;
public PizzaStore(SimpleFactory simpleFactory) {
this.simpleFactory = simpleFactory;
OrderPizza();
}
private void OrderPizza() {
Pizza pizza;
Scanner scanner = new Scanner(System.in);
String orderType;
while (true) {
System.out.println("输入披萨的种类:");
orderType = scanner.nextLine();
// 通过Pizza工厂获取Pizza对象
pizza = simpleFactory.createPizza(orderType);
if (null == pizza) {
break;
}
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
}
}
}
工厂方法模式:
抽象工厂模式:
-
抽象工厂模式定义了一个interface用于创建相关或有依赖关系的对象簇,而无需指明具体的类,可以将简单工厂模式和工厂方法模式进行整合
-
从设计层面看,抽象工厂模式就是对简单工厂模式的改进(或者称为进一步的抽象),将工厂抽象成两层,
-
实现思路
- 创建AbsFactory( 抽象工厂) 和具体实现的工厂子类,使用时创建工厂子类即可
-
UML类图
-
代码实现
-
// 抽象工厂类
public interface AbsFactory {
Pizza createPizza(String orderType);
}
// 子类1
public class BJFactory implements AbsFactory {
@Override
public Pizza createPizza(String orderType) {
Pizza pizza = null;
if (StringUtils.equals("cheese",orderType)) {
pizza = new BJPepperPizza("BJPepper");
} else {
System.out.println("没有该类型的披萨");
}
return pizza;
}
}
// 子类2
public class LDFactory implements AbsFactory {
@Override
public Pizza createPizza(String orderType) {
Pizza pizza = null;
if (StringUtils.equals("cheese",orderType)) {
pizza = new BJPepperPizza("LDPepper");
} else {
System.out.println("没有该类型的披萨");
}
return pizza;
}
}
-
public class PizzaStore {
public static void main(String[] args) {
new PizzaStore(new BJFactory());
}
private AbsFactory factory;
public PizzaStore(AbsFactory factory) {
// 在此处声明需要工厂类对象 , 使用时直接创建抽象工厂的子类对象即可
this.factory = factory;
OrderPizza();
}
private void OrderPizza() {
Pizza pizza;
Scanner scanner = new Scanner(System.in);
String orderType;
while (true) {
System.out.println("输入披萨的种类:");
orderType = scanner.nextLine();
// 使用抽象方法来创建Pizza,使用不同的实现类将会得到不同的披萨
pizza = factory.createPizza(orderType);
if (null == pizza) {
break;
}
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
}
}
}
jdk源码:
注意事项:
- 意义:将实例化对象的的代码抽取出来,放到一个类中同一管理和维护,在项目中达到依赖解耦的目的,提高项目的扩展性和维护性
- 依赖抽象原则(尽量依赖抽象的东西)
- 创建对象时,不要使用new,而是将new的东西放在一个工厂中并返回
- 不要让类继承一个具体的类,而是继承抽象类或者实现接口,不要覆盖基类汇总已经实现的方法
(编辑:李大同)
【声明】本站内容均来自网络,其相关言论仅代表作者个人观点,不代表本站立场。若无意侵犯到您的权利,请及时与联系站长删除相关内容!
|