`

【设计模式】工厂模式

 
阅读更多

工厂模式

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

该模式可以避免直接使用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
分享到：
| 【设计模式】装饰模式
评论
发表评论

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

相关推荐

    设计模式 工厂模式 java

    设计模式 工厂模式 java

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

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