【设计模式】工厂模式

最新推荐文章于 2024-08-31 18:16:35 发布
最新推荐文章于 2024-08-31 18:16:35 发布
阅读量132 收藏
点赞数
分类专栏： Design Pattern 文章标签： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/john_cena/article/details/84621805
版权

工厂模式

最核心的功能就是完成对象的创建；

该模式可以避免直接使用new操作符在客户端创建对象；

找出会变化的地方，将其从不变的代码中分离出来！

 

 

工厂模式的应用主要分以下4种：

 

一、静态工厂

通过静态方法返回对象。静态方法可以接收参数，然后根据传入的参数决定返回的对象。

 

二、简单工厂

将工厂组合到客户端，由客户端调用工厂来获取对象。

 

 * 简单工厂与静态工厂的区别：

静态工厂的行为不会改变，而简单工厂则可以再派生出子类来覆盖创建对象的行为！

 

三、工厂方法

将对象的创建委托给子类某个方法，父类通过顶层接口引用该方法返回的实例对象。

 

四、抽象工厂

创建系列产品时使用此模式；

抽象工厂是简单工厂和工厂方法结合使用的产物；

客户端组合抽象工厂与系列产品的接口，使用接口来引用抽象工厂所创建的对象。

 

 

一、静态工厂

 

package pattern.staticfactory;

import org.hqh.util.JUtil;
/**
 * 静态工厂
 */
public class ComputerFactory {
	/**
	 * 将具体实例化的过程从客户端分离出来
	 * 可能有很多客户端需要创建这些对象，当需要修改时，仅修改这里就可以了--->单点维护！ 
	 */
	public static Computer createComputer(ComputerType type) {
		if(type==ComputerType.ThinkPad)
			return new ThinkPad("TinkPad", 5000.00);
		if(type==ComputerType.Apple)
			return new Apple("Apple", 10000.00);
		throw new RuntimeException("Not support type:" + type.name());
	}
}

enum ComputerType {
	ThinkPad,Apple;
}

//该类不能被实例化，只能实例化其子类
abstract class Computer {
	protected String brand;
	protected double price;
	
	@Override
	public String toString() {
		return "Computer [brand=" + brand + ", price=" + JUtil.NumberFormator.format(price) + "]";
	}
	
}

class ThinkPad extends Computer {
	public ThinkPad(String brand, double price) {
		this.brand = brand;
		this.price = price;
	}
}

class Apple extends Computer {
	public Apple(String brand, double price) {
		this.brand = brand;
		this.price = price;
	}
}

 

package pattern.staticfactory;

public class Client {
	
	public void showCptList() {
		Computer thinkPad = ComputerFactory.createComputer(ComputerType.ThinkPad);
		System.out.println(thinkPad);
		
		Computer apple = ComputerFactory.createComputer(ComputerType.Apple);
		System.out.println(apple);
	}
	
	public static void main(String[] args) {
		Client c = new Client();
		c.showCptList();
	}
}

 

 

二、简单工厂



 

package pattern.simplefactory;

import org.hqh.util.JUtil;
/**
 * 简单工厂
 */
public class ComputerFactory {
	public Computer createComputer(ComputerType type) {
		if(type==ComputerType.ThinkPad)
			return new ThinkPad("TinkPad", 5000.00);
		if(type==ComputerType.Apple)
			return new Apple("Apple", 10000.00);
		throw new RuntimeException("Not support type:" + type.name());
	}
}

enum ComputerType {
	ThinkPad,Apple;
}

//该类不能被实例化，只能实例化其子类
abstract class Computer {
	protected String brand;
	protected double price;
	
	@Override
	public String toString() {
		return "Computer [brand=" + brand + ", price=" + JUtil.NumberFormator.format(price) + "]";
	}
	
}

class ThinkPad extends Computer {
	public ThinkPad(String brand, double price) {
		this.brand = brand;
		this.price = price;
	}
}

class Apple extends Computer {
	public Apple(String brand, double price) {
		this.brand = brand;
		this.price = price;
	}
}
package pattern.simplefactory;

public class Client {
	
	ComputerFactory factory;//组合工厂到客户端
	
	public Client(ComputerFactory factory) {
		this.factory = factory;
	}
	
	public void showCptList() {
		for(ComputerType type : ComputerType.values()) {
			Computer computer = factory.createComputer(type);
			System.out.println(computer);
		}
	}
	
	public static void main(String[] args) {
		ComputerFactory cptFactory = new ComputerFactory();
		Client c = new Client(cptFactory);
		c.showCptList();
	}
}

  

 

三、工厂方法
 

 

 

package pattern.factorymethod;

import org.hqh.util.JUtil;

public abstract class Computer {
	String brand;
	double price;
	
	@Override
	public String toString() {
		return "Computer [brand=" + brand + ", price=" + JUtil.NumberFormator.format(price) + "]";
	}

	public void test() {
		System.out.println("运行测试");
	}
	
	public void box() {
		System.out.println("装箱");
	}
	
}

class ComputerType {
	
	interface CommonType {}
	
	static enum ThinkPadType implements CommonType{
		E,X,T,S;
	}
	
	static enum AppleType implements CommonType{
		Air,Pro,iMac;
	}
}

class ThinkPad extends Computer {
	public ThinkPad(String brand, double price) {
		this.brand = brand;
		this.price = price;
	}
}

class Apple extends Computer {
	public Apple(String brand, double price) {
		this.brand = brand;
		this.price = price;
	}
}

 

package pattern.factorymethod;

import pattern.factorymethod.ComputerType.AppleType;
import pattern.factorymethod.ComputerType.ThinkPadType;

public abstract class ComputerStore {
	
	public Computer order(ComputerType.CommonType type) {
		Computer computer = assemble(type);
		computer.test();
		computer.box();
		return computer;
	}
	
	//工厂方法，将对象的创建延迟到子类中进行
	abstract Computer assemble(ComputerType.CommonType type);
}

class ThinkPadStore extends ComputerStore {
	@Override
	Computer assemble(ComputerType.CommonType type) {
		if(!(type instanceof ThinkPadType))
			throw new RuntimeException("ThinkPadStore not support type: " + type);
		return new ThinkPad(((ThinkPadType)type).name(), 5000.00);
	}
}

class AppleStore extends ComputerStore {
	@Override
	Computer assemble(ComputerType.CommonType type) {
		if(!(type instanceof AppleType))
			throw new RuntimeException("AppleStore not support type: " + type);
		return new ThinkPad(((AppleType)type).name(), 15000.00);
	}
}

 

package pattern.factorymethod;

public class Client {
	public static void main(String[] args) {
		ComputerStore thinkPadStore = new ThinkPadStore();
		Computer thinkPad = thinkPadStore.order(ComputerType.ThinkPadType.E);
		System.out.println(thinkPad);
		
		ComputerStore appleStore = new AppleStore();
		Computer apple = appleStore.order(ComputerType.AppleType.Air);
		System.out.println(apple);
		
	}
}

 

 

四、抽象工厂



 

package pattern.abstractmethod;

public abstract interface MaterialFactory {
	CPU createCPU();
	GraphicCard createGraphicCard();
}

class ThinkPadMaterialFacotry implements MaterialFactory {

	public CPU createCPU() {
		return new AMD();
	}

	public GraphicCard createGraphicCard() {
		return new ATI();
	}
	
}

class AppleMaterialFacotry implements MaterialFactory {

	public CPU createCPU() {
		return new Intel();
	}

	public GraphicCard createGraphicCard() {
		return new NVIDIA();
	}
	
}

 

package pattern.abstractmethod;

public abstract class CPU {

}

class Intel extends CPU {

	@Override
	public String toString() {
		return "Intel";
	}
}

class AMD extends CPU {
	@Override
	public String toString() {
		return "AMD";
	}
}

 

package pattern.abstractmethod;

public abstract class GraphicCard {

}

class NVIDIA extends GraphicCard {
	@Override
	public String toString() {
		return "NVIDIA";
	}
}

class ATI extends GraphicCard {
	@Override
	public String toString() {
		return "ATI";
	}
}

 

package pattern.abstractmethod;

import pattern.abstractmethod.ComputerType.AppleType;
import pattern.abstractmethod.ComputerType.ThinkPadType;

public abstract class ComputerStore {
	
	public Computer order(ComputerType.CommonType type) {
		Computer computer = create(type);//工厂方法
		computer.assemble();
		computer.test();
		computer.box();
		return computer;
	}
	
	//工厂方法，将对象的创建延迟到子类中进行
	abstract Computer create(ComputerType.CommonType type);
}

class ThinkPadStore extends ComputerStore {
	@Override
	Computer create(ComputerType.CommonType type) {
		if(!(type instanceof ThinkPadType))
			throw new RuntimeException("ThinkPadStore not support type: " + type);
		return new ThinkPad(((ThinkPadType)type).name(), 5000.00, 
					new ThinkPadMaterialFacotry());//传入工厂
	}
}

class AppleStore extends ComputerStore {
	@Override
	Computer create(ComputerType.CommonType type) {
		if(!(type instanceof AppleType))
			throw new RuntimeException("AppleStore not support type: " + type);
		return new ThinkPad(((AppleType)type).name(), 15000.00,
					new AppleMaterialFacotry());//传入工厂
	}
}

 

package pattern.abstractmethod;

import org.hqh.util.JUtil;

public abstract class Computer {
	String brand;
	double price;
	
	CPU cpu;
	GraphicCard graphicCard;
	
	public void test() {
		System.out.println("运行测试");
	}
	
	public void box() {
		System.out.println("装箱");
	}

	public abstract void assemble();

	@Override
	public String toString() {
		return "Computer [brand=" + brand + ", price=" + JUtil.NumberFormator.format(price) + ", cpu=" + cpu
				+ ", graphicCard=" + graphicCard + "]";
	}
	
}

class ComputerType {
	
	interface CommonType {}
	
	static enum ThinkPadType implements CommonType{
		E,X,T,S;
	}
	
	static enum AppleType implements CommonType{
		Air,Pro,iMac;
	}
}

class ThinkPad extends Computer {
	
	MaterialFactory factory;
	
	public ThinkPad(String brand, double price, MaterialFactory factory) {
		this.brand = brand;
		this.price = price;
		this.factory = factory;
	}

	@Override
	public void assemble() {
		this.cpu = factory.createCPU();//通过工厂创建原料
		this.graphicCard = factory.createGraphicCard();//通过工厂创建原料
	}
}

class Apple extends Computer {
	
	MaterialFactory factory;
	
	public Apple(String brand, double price, MaterialFactory factory) {
		this.brand = brand;
		this.price = price;
		this.factory = factory;
	}

	@Override
	public void assemble() {
		this.cpu = factory.createCPU();//通过工厂创建原料
		this.graphicCard = factory.createGraphicCard();//通过工厂创建原料
	}
}

 

package pattern.abstractmethod;

public class Client {
	public static void main(String[] args) {
		ComputerStore thinkPadStore = new ThinkPadStore();
		Computer thinkPad = thinkPadStore.order(ComputerType.ThinkPadType.E);
		System.out.println(thinkPad);
		
		ComputerStore appleStore = new AppleStore();
		Computer apple = appleStore.order(ComputerType.AppleType.Air);
		System.out.println(apple);
		
	}
}

 

spring:动态工厂，静态工厂
休对故人思故国，且将新火试新茶。诗酒趁年华
07-26 1431
Bean的装配之动态工厂方式 (1) 如何理解Bean的装配？ Bean的装配即bean（类对象）的装配 (2) 动态工厂方式创建Bean的步骤有哪些？ ① 注册工厂 <!--使用Factory动态工厂创建对象 --> <bean id="serviceFactory" class="com.bjsxt.beanFactory.ServiceFactory">&...
22种设计模式——工厂模式
meiziziLOLOLO的博客
02-22 769
文章目录1. 概述1.1 目的1.2 解决的问题2. 特点3. 实现3.1 具体实例3.2 UML类图3.3 Java代码 1. 概述 工厂方法模式是一种创建型设计模式， 其在父类中提供一个创建对象的方法， 允许子类决定实例化对象的类型。 1.1 目的 上面那段话其实就是工厂模式的目的，但说的比较抽象，这里来通俗地解释下。首先工厂模式是一种创建型模式，那很明显这个模式就是和对象的创建有关，所以对象的new操作就会比较特殊。在工厂模式中，对象不是直接在客户端中new出来，而是调用工厂类的工厂方法新建对象（也就
动态工厂 Bean和静态工厂Bean
Linn
07-26 5536
动态工厂 Bean 有些时候，项目中需要通过工厂类来创建 Bean 实例，而不能像前面例子中似的，直接由 Spring 容器来装配 Bean 实例。使用工厂模式创建 Bean 实例，就会使工厂类与要创建的Bean 类耦合到一起。（1 ）将动态工厂 Bean 作为普通 Bean 使用 将动态工厂 Bean 作为普通 Bean 来使用是指，在配置文件中注册过动态工厂 Bean 后，测试类直接通过
Spring 动态工厂和静态工厂区别
weixin_43667254的博客
04-01 2951
Spring 动态工厂和静态工厂区别 用过 Spring 系列的各位大牛应该都知道，这东西真香！ 但最近在学习整理Spring 全家桶的东西时，发现 Spring 的 Ioc（不懂去百度，我相信你搜到这篇废话不会不懂 Ioc 的） 一个小东西引起了我的注意，就是 Spring 的 bean 的xml 配置注入： public class Book { private Integer id...
静态工厂模式（简单工厂模式）与动态工厂模式（工厂方法模式）
最新发布
weixin_71894495的博客
08-31 664
本文介绍了静态工厂模式和动态工厂模式的优缺点及原理，最后通过代码实现进一步说明了两种模式的原理
Java设计模式之工厂模式（Factory模式）介绍
09-03
**工厂模式**是一种常见的设计模式，它在Java中被广泛应用于创建对象实例。工厂模式的主要目的是将对象的创建过程封装起来，使得代码更加灵活且易于维护。通过使用工厂模式，我们可以将实例化对象的责任从客户端代码...
设计模式深度解析：工厂方法模式与抽象工厂模式的深度对比
制定明确可量化的目标，坚持默默的做事。
03-11 9214
本文旨在深入对比软件设计模式中的工厂方法模式和抽象工厂模式。工厂方法模式侧重于定义一个用于创建对象的接口，让子类决定实例化哪一个类。它提供了一种封装机制，将对象的创建与使用分离，降低了耦合度。而抽象工厂模式则提供了一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。这种模式具有更强的扩展性，能够适应更为复杂的产品结构。通过对比分析，我们发现，两种模式各有优势，工厂方法模式更适用于单一产品的创建，而抽象工厂模式在处理产品族问题时更为得力。在选择使用哪种模式时，需根据具体的应用场景和需求进行综合考量
PHP最常用的2种设计模式工厂模式和单例模式介绍
01-20
1.工厂模式 主要作用是降低耦合度。 复制代码 代码如下: abstract class Operation{ abstract public function getValue($num1,$num2); public function getAttr(){ return 1; } } class Add extends Operation{ ...
设计模式单例模式和工厂模式综合应用
05-25
"设计模式单例模式和工厂模式综合应用"的主题聚焦于两种常用的设计模式：单例模式和工厂模式，并探讨它们如何协同工作来实现高效、灵活的代码结构。这个主题尤其适用于Java编程语言，因为Java的面向对象特性使得设计...
静态工厂方法和实例工厂方法区别
吴先森的技术专场
04-03 3641
静态工厂方法：工厂初始化之前，工厂中的类已经被实例化放在工厂容器中 实例工厂方法：工厂在构造方法初始化时，会将类进行实例化放在工厂中
Java 设计模式之静态工厂、工厂方法、抽象工厂和 Builder 模式的区别
牛角尖
09-27 1437
前面几篇文章，我们学习了几种工厂模式和 Builder 模式，都可以用来得到产品对象，那他们有什么区别呢？我们该怎么选择呢？
Spring---------静态与动态工厂
不怕万人阻挡，只怕自己投降
08-31 1775
话不多说，代码很简单，我直接发代码： 定义ISomeService接口： package com.myproject.ba2; public interface ISomeService { void doSome(); } ISomeService的实现类：下面被注释掉的是带参数构造 package com.bjpowernode.ba02; public class So...
spring静态工厂和实例工厂的区别
weixin_38816358的博客
11-06 4481
新闻实体类NewsBean package com.tang; /** * 新闻实体类 */ public class News { String title; String content; @Override public String toString() { return "News{" + "ti...
软件设计模式与体系结构【实验报告合集】
鸽子的博客
04-05 6074
四个实验（两学时）：策略模式、装饰者模式、抽象工厂模式、命令模式【没做GUI界面，只满足最简要求】 本文对你有用的话，记得点赞哦！以下是教科书&参考书 策略模式 Strategy Pattern 策略模式定义了算法族，分别封装起来，让他们之间可以互相替换，此模式让算法的变化独立于使用算法的客户。在熟悉策略模式相关理论知识的基础上，使用策略模式实现一个小游戏。 ...
设计模式之门面模式（外观模式） （十一）
|-| [- |_ |_ ()
06-07 954
说到了门面模式，有些地方又叫做外观模式，这个模式在平时做Web项目中应该是经常用到，像我们的Service层与DAO层，就是用到了门面模式，Controller层本来是需要跟一个个DAO打交道，但是有了Service层，它直接与DAO打交道，Controller就可以直接使用Service，我们只需专注在Service上写业务逻辑与操作DAO的各种方法，分离了责任，这个模式我认为最重要的功能就是解...
JAVA2实用教程 第四章中的例题（一）
落叶为了归根
06-09 1190
1.创建对象，分配变量class xiyoujirenwu{ float height,weight; String head,ear; void speak(String s) { System.out.println(s); } } public class EX4_1 { public static void main(String args[]) { xiyoujiren...
Factory Pattern 工厂模式
Geurney的专栏
07-04 507
If your code is written to an interface, then it will work with any new classes implementing that interface through polymorphism. However, when you have code that makes use of lots of concrete classes
C#深入浅出：设计模式工厂模式详解
深入浅出设计模式是一本专注于C#编程领域的书籍，作者AI92主要讲解了如何在C#中理解和应用设计模式，以解决软件开发中的常见问题和提高代码的可扩展性和灵活性。本书的核心内容围绕着工厂模式展开，这是一种在面向...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值