`

【设计模式】工厂模式

 
阅读更多

工厂模式

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

该模式可以避免直接使用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);
		
	}
}

 

  • 大小: 5.3 KB
  • 大小: 22.1 KB
  • 大小: 48.2 KB
分享到：
| 【设计模式】装饰模式
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    设计模式 工厂模式 VC++

    工厂模式是一种创建型设计模式，它提供了一种创建对象的最佳方式。在这个VC++相关的案例中，我们将深入探讨工厂模式如何在C++环境中应用。 工厂模式的核心思想是通过一个公共的接口或者抽象类来创建对象，而不是...

    设计模式单例模式和工厂模式综合应用

    "设计模式单例模式和工厂模式综合应用"的主题聚焦于两种常用的设计模式：单例模式和工厂模式，并探讨它们如何协同工作来实现高效、灵活的代码结构。这个主题尤其适用于Java编程语言，因为Java的面向对象特性使得设计...

    设计模式 工厂模式（附源码）

    工厂模式是一种常用的设计模式，它是创建型模式的一种，主要用于解决对象创建的问题。在软件工程中，当类的数量庞大且它们之间存在复杂的依赖关系时，直接实例化对象可能会导致代码复杂度增加，不易维护。工厂模式...

    JAVA 设计模式 工厂模式 代理模式 迭代模式 责任链模式 源码

    1. **工厂模式**：工厂模式是一种创建型设计模式，它提供了一种创建对象的最佳方式。在工厂模式中，当创建对象时，我们不会对客户端暴露创建逻辑，而是让客户端通过使用一个共同的接口来请求所需的对象。这样做的...

    深入浅出设计模式之工厂模式

    根据提供的标题“深入浅出设计模式之工厂模式”与描述“将《Head First 设计模式》(中文版)按章节进行了分割，每章一个文件，方便大家下载”，我们可以推测出这部分内容主要关注的是设计模式中的工厂模式。...

    设计模式_工厂模式

    设计模式是软件工程中的一种最佳实践，用于解决常见的设计问题并提供可重用的解决方案。在这些模式中，工厂模式是一种创建型模式，它提供了一种封装对象创建过程的方法，使得客户端代码无需直接实例化对象，而是通过...

    设计模式工厂方法模式PPT学习教案.pptx

    "设计模式工厂方法模式PPT学习教案" 本学习教案旨在讲解设计模式中的工厂方法模式（Factory Method），通过学习本教案，学生将掌握工厂方法模式的定义、结构、实例、分析和应用。 模式动机与定义 在软件设计中，...

    抽象工厂设计模式抽象工厂设计模式

    抽象工厂设计模式抽象工厂设计模式 抽象工厂设计模式 抽象工厂设计模式 抽象工厂设计模式 抽象工厂设计模式 抽象工厂设计模式

    java设计模式之工厂模式

    java设计模式之工厂模式java设计模式之工厂模式java设计模式之工厂模式java设计模式之工厂模式java设计模式之工厂模式java设计模式之工厂模式java设计模式之工厂模式java设计模式之工厂模式java设计模式之工厂模式...

    JAVA设计模式工厂模式之简单工厂[定义].pdf

    【Java设计模式：工厂模式之简单工厂】 简单工厂模式是一种常用的设计模式，它提供了一种创建对象的最佳方式，尤其在需要根据条件创建不同类的对象时。在Java中，简单工厂模式通过一个工厂类来集中创建对象，避免了...

    设计模式学习笔记(一)--简单工厂模式源码

    简单工厂模式是软件设计模式中的一种基础模式，它属于创建型模式，主要解决对象的创建问题，降低了系统与具体创建对象之间的耦合度。在这个学习笔记中，我们将深入理解简单工厂模式的概念、工作原理以及如何在实际...

    设计模式在android中的应用之1，简单工厂模式

    简单工厂模式是软件设计模式中的一种创建型模式，它提供了一种创建对象的最佳方式。在Android开发中，尤其是在处理各种视图组件或者不同类型的数据库操作时，简单工厂模式能够简化代码，提高代码的可读性和可维护性...

    专题资料（2021-2022年）java常用设计模式工厂模式的实现.doc

    工厂模式是设计模式中最基础且常用的一种，用于创建对象时封装实例化过程。本篇专题资料详细介绍了工厂模式在Java中的实现，特别是通过一个农场的实例来帮助理解。 首先，简单工厂模式是最直观的工厂模式形式，它...

    软件体系结构与设计模式第十二章工厂方法模式.pptx

    软件体系结构与设计模式第十二章工厂方法模式 工厂方法模式是一种常用的设计模式，它定义了一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method使一个类的实例化延迟到其子类。这种模式的主要作用是...

    设计模式——工厂方法模式

    工厂方法模式是面向对象设计模式中的一种，它属于创建型模式，主要解决的是当系统需要创建的对象具有多种类型，而具体创建哪种类型的对象在运行时才能确定的问题。在这个压缩包中，`FactoryMethod`可能包含了Java...

    设计模式资料之工厂设计模式

    总结来说，这份“设计模式资料之工厂设计模式”可能会涵盖工厂模式的基本概念、分类、作用，尤其是重点讲解抽象工厂模式的原理、应用场景及实现方式。通过学习这些内容，开发者将能更好地理解和运用设计模式，提升...

    工厂设计模式代码

    工厂设计模式是软件工程中广泛使用的一种创建型设计模式，它的主要目的是为了隔离对象的创建过程，使得客户端代码不直接创建对象，而是通过一个专门的工厂类来负责对象的实例化。这种模式使得系统在面对产品扩展时...

    深入浅出设计模式四——比萨店生产比萨实现(工厂方法模式）

    在IT行业中，设计模式是软件开发中的重要概念，它们代表了在特定场景下解决常见问题的最佳实践。本文将深入探讨“工厂方法模式”，并结合比萨店生产比萨的实例来解析这一模式的运用。首先，我们要理解工厂方法模式的...

    设计模式之工厂模式Java实现和类设计图

    在软件开发中，设计模式是经验丰富的开发者们总结出的解决常见问题的模板或最佳实践。工厂模式作为其中的一种，是对象创建型模式，它的主要目的是为了隔离对象创建过程与客户端之间的关系，使得创建过程更加灵活，...

Magicbox
Global site tag (gtag.js) - Google Analytics