设计模式 3种工厂模式的写法及分析

最新推荐文章于 2024-08-05 14:57:08 发布
最新推荐文章于 2024-08-05 14:57:08 发布
阅读量505 收藏 4
点赞数 2
分类专栏： 设计模式 文章标签： 设计模式 工厂模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cong____cong/article/details/104713226
版权

设计模式分类

  1. 创建型模式：单例模式、抽象工厂模式、原型模式、建造者模式、工厂模式。

  2. 结构型模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。

  3. 行为型模式：模版方法模式、命令模式、访问者模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式(Interpreter 模式)、状态模式、策略模式、职责链模式(责任链模式)。

首先来看一个需求：

  1. 披萨的种类很多(比如GreekPizz、 CheesePizz 等)
  2. 披萨的制作有prepare, bake, cut, box
  3. 完成披萨店订购功能。

传统方式

UML类图

根据需求我们可以对代码进行实现

// 启动测试
public class PizzaOrder {
	public static void main(String[] args) {
		System.out.println("请输入披萨类型：");
		new OrderPizza();
	}
}
// 披萨抽象类
abstract class Pizza{
	public String name;
	// 构造的时候设置名称
	public Pizza(String name) {
		this.name = name;
	}
	// 根据类型不同准备不同材料
	public abstract void prepare();
	// 烤焙
	public void bake() {
		System.out.println(name + " baking");
	}
	// 切割
	public void cut() {
		System.out.println(name + " cuting");
	}
	// 装箱
	public void box() {
		System.out.println(name + " boxing");
	}
}
// 奶酪披萨
class CheesesPizza extends Pizza {
	public CheesesPizza(String name) {
		super(name);
	}
	@Override
	public void prepare() {
		System.out.println("正在奶酪披萨准备原材料...");
	}
}
// 希腊披萨
class GreekPizza extends Pizza{
	public GreekPizza(String name) {
		super(name);
	}
	@Override
	public void prepare() {
		System.out.println("正在希腊披萨准备原材料...");
	}
}
// 订购披萨
class OrderPizza{
	// 构造器
	public OrderPizza() {
		Pizza pizza = null;
		String orderType = null;
		Scanner scan = new Scanner(System.in);
		do {
			orderType = scan.next(); //假设订购希腊披萨
			if(orderType.equalsIgnoreCase("greek")) {
				pizza = new GreekPizza("希腊披萨");
			}else if(orderType.equalsIgnoreCase("cheeses")) {
				pizza = new CheesesPizza("奶酪披萨");
			}else {
				break;
			}
			pizza.prepare();
			pizza.bake();
			pizza.cut();
			pizza.box();
		}while(true);
	}
}

分析

优点：是比较好理解，简单易操作。
缺点：违反了 设计模式的ocp原则，即对扩展开放，对修改关闭。即当我们给类增加新功能的时候，尽量不修改代码，或者尽可能少修改代码。

比如我们这 时要新增加一一个Pizza的种类(Pepper披萨)，我们需要新增一个 PepperPizza 类，同时需要修改 OrderPizza 方法，比较麻烦，而且如果存在其他关系的话可能也随之需要修改，提高了代码的维护成本。

改进思路

修改代码可以接受，但是如果我们在其它的地方也有创建 Pizza 的代码，就意味着，也需要修改，而创建 Pizza 的代码，往往有多处。所以把创建 Pizza 对象封装到一个类中，这样我们有新的 Pizza 种类时，只需要修改该类就可，其它有创建到 Pizza 对象的代码就不需要修改了->简单工厂模式

简单工厂模式

  1. 简单工厂模式是属于创建型模式，是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建出哪-种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式
  2. 简单工厂模式：定义了一个创建对象的类，由这个类来封装实例化对象的行为(代码)
  3. 在软件开发中，当我们会用到大量的创建某种、某类或者某批对象时，就会使用到工厂模式

改进UML类图

代码实现

import java.util.Scanner;
// 启动测试
public class PizzaOrder {
	public static void main(String[] args) {
		System.out.println("请输入披萨类型：");
		OrderPizza orderPizza = new OrderPizza();
		SimpleFactory simpleFactory = new SimpleFactory();
		orderPizza.setSimpleFactory(simpleFactory);
	}
}
// 披萨抽象类
abstract class Pizza{
	public String name;
	// 构造的时候设置名称
	public Pizza(String name) {
		this.name = name;
	}
	// 根据类型不同准备不同材料
	public abstract void prepare();
	// 烤焙
	public void bake() {
		System.out.println(name + " baking");
	}
	// 切割
	public void cut() {
		System.out.println(name + " cuting");
	}
	// 装箱
	public void box() {
		System.out.println(name + " boxing");
	}
}
// 奶酪披萨
class CheesesPizza extends Pizza {
	public CheesesPizza(String name) {
		super(name);
	}
	@Override
	public void prepare() {
		System.out.println("正在奶酪披萨准备原材料...");
	}
}
// 希腊披萨
class GreekPizza extends Pizza{
	public GreekPizza(String name) {
		super(name);
	}
	@Override
	public void prepare() {
		System.out.println("正在希腊披萨准备原材料...");
	}
}
// 订购披萨
class OrderPizza {
	
	private SimpleFactory simpleFactory = null;
	
	//设置工厂
	public void setSimpleFactory(SimpleFactory simpleFactory) {
		this.simpleFactory = simpleFactory;
		Pizza pizza = null;
		String orderType = null;
		Scanner scan = new Scanner(System.in);
		do {
			orderType = scan.next();
			pizza = simpleFactory.createPizza(orderType);
			if(pizza != null) {
				pizza.prepare();
				pizza.bake();
				pizza.cut();
				pizza.box();
			}else {
				System.out.println("不存在");
				break;
			}
		}while(true);
	}
}
// 简单工厂类(新增披萨只需要修改工厂类即可)
class SimpleFactory {
	public Pizza pizza = null;
	public Pizza createPizza(String orderType) {
		if(orderType.equalsIgnoreCase("greek")) {
			pizza = new GreekPizza("希腊披萨");
		}else if(orderType.equalsIgnoreCase("cheeses")) {
			pizza = new CheesesPizza("奶酪披萨");
		}
		return pizza;
	}
}

分析

这样修改过后，订购披萨类只需要注入工厂对象，而无需关心对象生成的过程。也可以将工厂中的 create 方法声明为静态方法，就转换为了静态工厂模式。

新需求

披萨项目新的需求：客户在点披萨时，可以点不同口味的披萨，比如北京的奶酪pizza、北京的胡椒 pizza 或者是伦敦的奶酪pizza、伦敦的胡椒 pizza。

思路1

使用简单工厂模式，创建不同的简单工厂类，比如 BJPizzaSimpleFactory、 LDPizzaSimpleFactory 等等。从当前这个案例来说，也是可以的，但是考虑到项目的规模，以及软件的可维护性、可扩展性并不是特别好

思路2

使用工厂方法模式

工厂方法模式

工厂方法模式：定义了一个创建对象的抽象方法，由子类决定要实例化的类。工厂方法模式将对象的实例化推迟到子类。

设计方案：将披萨项目的实例化功能抽象成抽象方法，在不同的口味点餐子类中具体实现。

UML类图

代码实现

import java.util.Scanner;
// 启动测试
public class PizzaOrder {
	public static void main(String[] args) {
		System.out.println("请输入披萨类型：");
		// 根据需求 new 不同的对象即可
		new BJOrderPizza();
		new LDOrderPizza();
	}
}
// 披萨抽象类
abstract class Pizza{
	public String name;
	// 构造的时候设置名称
	public Pizza(String name) {
		this.name = name;
	}
	// 根据类型不同准备不同材料
	public abstract void prepare();
	// 烤焙
	public void bake() {
		System.out.println(name + " baking");
	}
	// 切割
	public void cut() {
		System.out.println(name + " cuting");
	}
	// 装箱
	public void box() {
		System.out.println(name + " boxing");
	}
}
// 北京奶酪披萨
class BJCheesesPizza extends Pizza {
	public BJCheesesPizza(String name) {
		super(name);
	}
	@Override
	public void prepare() {
		System.out.println(" 北京奶酪披萨准备原材料");
	}
}
// 北京希腊披萨
class BJGreekPizza extends Pizza {
	public BJGreekPizza(String name) {
		super(name);
	}
	@Override
	public void prepare() {
		System.out.println(" 北京希腊披萨准备原材料");
	}
}
//伦敦奶酪披萨
class LDCheesesPizza extends Pizza {
	public LDCheesesPizza(String name) {
		super(name);
	}
	@Override
	public void prepare() {
		System.out.println(" 伦敦奶酪披萨准备原材料");
	}
}
//伦敦希腊披萨
class LDGreekPizza extends Pizza {
	public LDGreekPizza(String name) {
		super(name);
	}
	@Override
	public void prepare() {
		System.out.println(" 伦敦希腊披萨准备原材料");
	}
}
//订购披萨抽象类
abstract class OrderPizza {
	// 抽象方法，工厂子类实现
	abstract Pizza createPizza(String orderType);
	// 订购披萨
	public OrderPizza() {
		Pizza pizza = null;
		String orderType = null;
		Scanner scan = new Scanner(System.in);
		do {
			orderType = scan.next();
			pizza = createPizza(orderType);// 创建披萨对象由子类实现
			if(pizza != null) {
				pizza.prepare();
				pizza.bake();
				pizza.cut();
				pizza.box();
			}else {
				System.out.println("不存在");
				break;
			}
		}while(true);
	}
}
// 北京
class BJOrderPizza extends OrderPizza{
	@Override
	Pizza createPizza(String orderType) {
		Pizza pizza = null;
		if(orderType.equalsIgnoreCase("cheese")) {
			pizza = new BJCheesesPizza("北京奶酪披萨");
		}else if(orderType.equalsIgnoreCase("greek")) {
			pizza = new BJGreekPizza("北京奶酪披萨");
		}
		return pizza;
	}
}
// 伦敦
class LDOrderPizza extends OrderPizza{
	@Override
	Pizza createPizza(String orderType) {
		Pizza pizza = null;
		if(orderType.equalsIgnoreCase("cheese")) {
			pizza = new LDCheesesPizza("伦敦奶酪披萨");
		}else if(orderType.equalsIgnoreCase("greek")) {
			pizza = new LDGreekPizza("伦敦奶酪披萨");
		}
		return pizza;
	}
}

分析

将中间层进一步划分为抽象，新增分类层，可以很好的解决这个需求，同时保证了代码的质量。

抽象工厂模式

抽象工厂 模式：定义了一个 interface 用于创建相关或有依赖关系的对象簇，而无需指明具体的类。
可以将简单工厂模式和工厂方法模式进行整合。从设计层面看，抽象工厂模式就是对简单工厂模式的改进(或者称为进一步的抽象)。

将工厂抽象成两层，AbsFactory(抽象工厂)和具体实现的工厂子类。程序员可以根据创建对象类型使用对应的工厂子类。这样将单个的简单工厂类变成了工厂簇，更利于代码的维护和扩展。

UML类图

代码实现

import java.util.Scanner;
// 启动测试
public class PizzaOrder {
	public static void main(String[] args) {
		System.out.println("请输入披萨类型：");
		// 根据需求 new 不同的对象即可
		new OrderPizza(new BJFactory());
		new OrderPizza(new LDFactory());
	}
}
// 披萨抽象类
abstract class Pizza{
	public String name;
	// 构造的时候设置名称
	public Pizza(String name) {
		this.name = name;
	}
	// 根据类型不同准备不同材料
	public abstract void prepare();
	// 烤焙
	public void bake() {
		System.out.println(name + " baking");
	}
	// 切割
	public void cut() {
		System.out.println(name + " cuting");
	}
	// 装箱
	public void box() {
		System.out.println(name + " boxing");
	}
}
// 北京奶酪披萨
class BJCheesesPizza extends Pizza {
	public BJCheesesPizza(String name) {
		super(name);
	}
	@Override
	public void prepare() {
		System.out.println(" 北京奶酪披萨准备原材料");
	}
}
// 北京希腊披萨
class BJGreekPizza extends Pizza {
	public BJGreekPizza(String name) {
		super(name);
	}
	@Override
	public void prepare() {
		System.out.println(" 北京希腊披萨准备原材料");
	}
}
//伦敦奶酪披萨
class LDCheesesPizza extends Pizza {
	public LDCheesesPizza(String name) {
		super(name);
	}
	@Override
	public void prepare() {
		System.out.println(" 伦敦奶酪披萨准备原材料");
	}
}
//伦敦希腊披萨
class LDGreekPizza extends Pizza {
	public LDGreekPizza(String name) {
		super(name);
	}
	@Override
	public void prepare() {
		System.out.println(" 伦敦希腊披萨准备原材料");
	}
}
//订购披萨抽象类
class OrderPizza {
	// 抽象方法，工厂子类实现
	AbsFactory absFactory;
	// 构造器，设置工厂
	public OrderPizza(AbsFactory absFactory) {
		this.absFactory = absFactory;
		Pizza pizza = null;
		String orderType = null;
		Scanner scan = new Scanner(System.in);
		do {
			orderType = scan.next();
			// 调用接口方法创建披萨对象
			pizza = absFactory.createPizza(orderType);
			if(pizza != null) {
				pizza.prepare();
				pizza.bake();
				pizza.cut();
				pizza.box();
			}else {
				System.out.println("不存在");
				break;
			}
		}while(true);
	}
}
// 抽象工程模式的抽象层
interface AbsFactory {
	// 抽象方法，由实现类实现
	public Pizza createPizza(String orderType);
}
//北京工厂
class BJFactory implements AbsFactory {
	@Override
	public Pizza createPizza(String orderType) {
		Pizza pizza = null;
		if(orderType.equalsIgnoreCase("cheese")) {
			pizza = new BJCheesesPizza("北京奶酪披萨");
		}else if(orderType.equalsIgnoreCase("greek")) {
			pizza = new BJGreekPizza("北京希腊披萨");
		}
		return pizza;
	}
}
//伦敦工厂
class LDFactory implements AbsFactory {
	@Override
	public Pizza createPizza(String orderType) {
		Pizza pizza = null;
		if(orderType.equalsIgnoreCase("cheese")) {
			pizza = new LDCheesesPizza("伦敦奶酪披萨");
		}else if(orderType.equalsIgnoreCase("greek")) {
			pizza = new LDGreekPizza("伦敦希腊披萨");
		}
		return pizza;
	}
}

分析

这种模式解决了项目中有多种地区，不同种类的披萨的问题。适合种类比较多的场景使用。

源码使用

Java 在日历类 Calendar 类中运用到了简单工程模式

总结

工厂模式的意义：将实例化对象的代码提取出来，放到一个类中统一管 理和维护，达到和主项目的依赖关系的解耦。从而提高项目的扩展和维护性。
三种工厂 模式：简单工厂模式、工厂方法模式、抽象工厂模式
设计模式的依赖抽象原则

  • 创建对象实例时， 不要直接new类，而是把这个new类的动作放在一个工厂的方法中，并返回。有的书上说，变量不要直接持有具体类的引用。
  • 不要让类继承具体类， 而是继承抽象类或者是实现interface(接 口)
  • 不要覆 盖基类中已经实现的方法。
楚瑞涛
关注
专栏目录
设计模式——工厂模式
记录只为更好地前行
07-04 4723
工厂模式 在《Head First 设计模式》一书中，一共介绍了一种类似于工厂模式的编程习惯、两种工厂模式，在这篇文章中，我将对它们分别进行介绍，下面首先来看一下简单工厂。 1、简单工厂 按照惯例，我们应该先介绍一下简单工厂的定义，然后举例说明，这一次，我们不这样做，我们首先举例说明，然后再引出简单工厂的定义，后续两个工厂模式均按此方式进行叙述，从案例中理解模式的定义才能够更加印象深刻。...
设计模式 单例模式的8种写法及分析
cong____cong的博客
03-06 249
设计模式分类 创建型模式:单例模式、抽象工厂模式、原型模式、建造者模式、工厂模式。 结构型模式: 适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。 行为型模式: 模版方法模式、命令模式、访问者模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式(Interpreter 模式)、状态模式、策略模式、职责链模式(责任链模式)。 单例模式 ...
工厂设计模式（三种）详解
weixin_30246221的博客
02-18 3395
什么是工厂设计模式？ 工厂设计模式，顾名思义，就是用来生产对象的，在java中，万物皆对象，这些对象都需要创建，如果创建的时候直接new该对象，就会对该对象耦合严重，假如我们要更换对象，所有new对象的地方都需要修改一遍，这显然违背了软件设计的开闭原则，如果我们使用工厂来生产对象，我们就只和工厂打交道就可以了，彻底和对象解耦，如果要更换对象，直接在工厂里更换该对象即可，达到了与...
【设计模式】——抽象工厂模式（Abstract Factory Pattern）
最新发布
J^T的博客
08-05 855
抽象工厂模式是所有形态的工厂模式中最抽象和最具一般性的一种。它适用于处理具有产品族（即一组相互关联或相互依赖的产品）的产品结构。产品族是指位于不同等级结构中的一组产品，它们之间可能存在一定的依赖或约束关系。抽象工厂模式通过定义一个接口，使得客户端可以在不必指定具体产品的情况下，创建多个产品族中的产品对象。
工厂设计模式(三种) — 创建型
ezconn的博客
06-07 707
简介 工厂模式（Factory Design Pattern）：也是创建型中常用设计模式；又可细分为三种类型：简单工厂，工厂方法，抽象工厂；工厂顾名思义就是生产产品，在这里是指创建对象； 简单工厂模式 下面通过动物饲养的例子，实现简单工厂模式； 1，创建一个动物接口： public interface Animal {//动物抽象 void eat();//动物的行为 } 2，具体的动物类（具体对象类） public class Dog implements Animal {
设计模式之工厂模式
一个学习的人的博客
09-14 283
概念与用处 工厂设计模式是二十三个设计模式之一。 耦合性（向上转型）：指一个类(A)严重依赖另外一个类(B)，如果需要替换掉类B的话，需要修改A的代码，简单点说，new出来的对象都有耦合性，因为想给new出来的对象替换掉，就需要修改类中的源代码。 工厂设计模式 1、专门隐藏实例化对象的过程，假如我们写一个类，在创建对象的时候需要读取一些文件，然后接收很多参数，这个时候我们就可以使用工厂设计模式将创建对象的过程抽离出来，然后形成一个工厂类。 2、解决耦合性的问题。 分类 一简单工厂 实现步骤： 1、实现类的共
三种工厂的设计模式
包包的博客
05-05 372
文章目录一、 三种模式概括1、简单工厂模式2、工厂方法模式3、抽象工厂模式二、三种设计模式的UML类图1、简单工厂模式2、工厂方法模式3、抽象工厂模式三、三种设计模式的源代码四、总结分析 一、 三种模式概括 1、简单工厂模式 实例化对象的时候不再使用 new Object()形式，可以根据用户的选只需要给出具体 实例的描述给工厂，工厂就会自动返回具体的实例对象。择条件来实例化相关的类。 对于客户端...
Java：单例模式的七种写法
12-22
免线程同步问题，而且还能防止反序列化重新创建新的对象，绝对的线程安全，同时也能保证单例的唯一性。...同时，单例模式也常常与其他设计模式结合使用，如工厂模式、建造者模式等，以解决更复杂的问题。
qt工厂模式例子qt简单工程模式源码
07-04
3. Qt工厂模式工程 4. Qt工厂模式例程 5. Qt工厂模式例子 6. 简单工厂模式 部分源码实例: // 奔驰工厂 class BenzFactory : public AFactory { public: ICar* CreateCar() { return new BenzCar(); } }; // ...
工厂模式的三种写法
09-06
工厂模式是一种常用的软件设计模式，它是创建型设计模式的一种，主要解决对象创建的问题。工厂模式的核心思想是将对象的创建过程封装起来，使得创建过程独立于使用对象的代码，从而提高了代码的可扩展性和可维护性。...
设计模式.xmind
06-19
设计模式 创建型6种 单例模式 单例模式五种写法 工厂模式 建造者模式 原型模式 结构型7种 适配器模式 代理模式 装饰模式 桥接模式 组合模式 享元模式 行为型11种 模板方法模式 观察者...
详解设计模式 - 工厂模式（3种）
Zebe
11-01 736
这篇文章作为个人学习备忘笔记，通过生活中的牛奶工厂实例，比对3种工厂模式的不同。 工厂模式一句话总结： 只对生产结果负责，不要三无产品。 生活中的工厂例子 小作坊：五花八门什么都能生产，但生产质量和产品种类不一定满足消费者的需求。 专业工厂：遵循一定标准，不生产其他产品，只专注于自己的产品，不断精益求精。 大型国际工厂：专业、高效，无论是产品质量还是产品种类，都能让用户放心。 以上这三种工厂...
【设计模式】工厂模式
放开这颗白菜让我来
03-02 70
大家好，我是被白菜拱的猪。 一个热爱学习废寝忘食头悬梁锥刺股，痴迷于girl的潇洒从容淡然coding handsome boy。
设计模式 – 工厂模式
qq_34125999的博客
10-20 1863
1 简单工厂模式 简单工厂模式是属于创建型模式，是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式。 优点：客户端不需要再负责对象的创建，仅仅调用工厂，工厂帮你创建需要的对象。并且把对象的创建和使用进行解耦，方便管理。 缺点：违反了开闭原则。 demo：水果工厂制作水果 public abstract class Fruit { public abstract String getName(); } public clas
23种设计模式——工厂模式
热门推荐
万里顾一程的博客
06-11 1万+
文章目录23种设计模式——工厂模式1、工厂模式概述2、简单工厂模式2.1、简单工厂模式的优缺点2.2、简单工厂模式的结构2.3、简单工厂模式的实现3、工厂方法模式3.1、工厂方法模式的优缺点3.2、工厂方法模式的结构3.3、工厂方法模式的实现4、抽象工厂模式4.1、抽象工厂模式概述4.2、抽象工厂模式结构4.3、抽象工厂模式实现 23种设计模式——工厂模式 1、工厂模式概述 工厂模式的定义：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。这满足创建型模式中所要
设计模式_工厂模式
青墨
03-30 275
理解：工厂模式就是专门负责将大量有共同接口的类实例化,而且不必事先知道每次是要实例化哪一个类的模式。它定义一个用于创建对象的接口，由子类决定实例化哪一个类。   意图：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。   主要解决：主要解决接口选择的问题。   何时使用：我们明确地计划不同条件下创建不同实例时。   如何解决：让其子类
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值