创建型——工厂系列（Factory）day04

最新推荐文章于 2025-10-10 19:40:35 发布
原创 最新推荐文章于 2025-10-10 19:40:35 发布 · 2.4k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#设计模式

本文深入探讨了工厂模式的各种形态，包括简单工厂、工厂方法和抽象工厂，解析了它们的设计原理、应用场景及优缺点，并通过实例代码展示了如何实现这些模式。
  • 任何可以产生对象的方法或类，都可以称为工厂
  • 单例也是一种工厂
  • 为什么有了new以后，还要有工厂？
    1、灵活控制生产过程
    2、权限、修饰、日志……

接口模式

在这里插入图片描述

package cn.xhl.interfacemodel;

public interface IFruit {
	public void plant();
	public void harvest();
	public void grow();
}

package cn.xhl.interfacemodel;

public class Apple implements IFruit {
	int treeAge = 5;
	public void plant() {
		// TODO Auto-generated method stub
		log("苹果种植ֲ********");
	}

	public void harvest() {
		// TODO Auto-generated method stub
		log("苹果收获******");
	}
	public void grow() {
		// TODO Auto-generated method stub
		log("苹果增长****");
	}
	public static void log(String msg) {
		System.out.println(msg);
	}

}

package cn.xhl.interfacemodel;

public class Grape implements IFruit {
	boolean seedful=false;
	public void plant() {
		// TODO Auto-generated method stub
		log("葡萄种植ֲ********");
	}

	public void harvest() {
		// TODO Auto-generated method stub
		log("葡萄收获******");
	}
	public void grow() {
		// TODO Auto-generated method stub
		log("葡萄生长****");
	}
	public static void log(String msg) {
		System.out.println(msg);
	}

}

package cn.xhl.interfacemodel;

public class Strawberry implements IFruit {

	public void plant() {
		// TODO Auto-generated method stub
		log("草莓种植********");
	}

	public void harvest() {
		// TODO Auto-generated method stub
		log("草莓收获******");
	}
	public void grow() {
		// TODO Auto-generated method stub
		log("草莓生长****");
	}
	public static void log(String msg) {
		System.out.println(msg);
	}

}

package cn.xhl.interfacemodel;

public class Client1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		IFruit[] fruits = {new Grape(),new Strawberry(),new Apple()};
		for(IFruit fruit : fruits) {
			fruit .plant();
			fruit.grow();
			fruit .harvest();
		}
	}

}

简单工厂模式

在这里插入图片描述
一般情况下我们可以用一个FruitFactory去创建不同的Fruit

public class FruitFactory{
	public IFruit creatApple(){
		//进行一些前置操作,例如设置权限、进行修饰、打印日志……
		return new Apple();
	}
	public IFruit creatGrape(){return new Grape();}
	public IFruit creatStrawberry(){return new Strawberry();}
}

但是这不符合开闭原则，每次新增一个品种的IFruit都需要对Factory进行改动。

我们可以对简单工厂模式进行改进，让它符合开闭原则。

package cn.xhl.simpleFactory;

public class FruitGardent {
	public static IFruit factory(String which) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
		IFruit fruit = null;
		String pn = FruitGardent.class.getPackage().getName();
		StringBuilder sb = new StringBuilder();
		sb.append(pn);
		sb.append(".");
		sb.append(Character.toUpperCase(which.charAt(0)));
		sb.append(which.substring(1).toLowerCase());
		fruit = (IFruit) Class.forName(sb.toString()).newInstance();
		return fruit;
	}
}


package cn.xhl.simpleFactory;

public class Client1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String[] strs = {"grape","apple","strawberry"};
		for(String str : strs) {
			IFruit fruit;
			try {
				fruit = FruitGardent.factory(str);
				fruit.plant();
				fruit.harvest();
			} catch (InstantiationException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (IllegalAccessException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (ClassNotFoundException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

}

但是这有产生了新的问题，如果对不同的产品对应需要给到不同的权限，也就是在new之前需要进行一些前置操作，且不同的IFruit操作不一样，这样就需要在前面加上判断的语句，判断这是什么IFruit，再进行一些权限设置，最后再创建对象，但这又不符合开闭原则了。

于是我们可以对每一个产品，也就是每一个IFruit都用一个Factory，这样就引出了工厂方法模式。

工厂方法模式

工厂方法方便产品的扩展
在这里插入图片描述

package factory1;

public class Client1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String[] strs = {"ConcreateCreator1","ConcreateCreator2"};
		for (String str : strs) {
			try {
				Creator creator = CreatFactory.factory(str);
				creator.factory().show();
			} catch (InstantiationException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (IllegalAccessException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (ClassNotFoundException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			
		}
	}

package factory1;

public class CreatFactory {
	public static Creator factory(String which) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
		Creator creator = null;
		
		
		StringBuilder sb = new StringBuilder();
		sb.append(CreatFactory.class.getPackageName());
		sb.append(".");
		sb.append(which);
		creator = (Creator) Class.forName(sb.toString()).newInstance();
		return creator;
	}
}

package factory1;

public interface Creator {
	public Product factory();
}

package factory1;

public class ConcreateCreator1 implements Creator {

	@Override
	public Product factory() {
		// 可以进行一些前置操作,例如设置权限、进行修饰、打印日志……
		return new ConcreateProduct1();
	}

}


package factory1;

public class ConcreateCreator2 implements Creator {

	@Override
	public Product factory() {
		// TODO Auto-generated method stub
		return new ConcreateProduct2();
	}

}


package factory1;

public interface Product {
	public void show();

}

package factory1;

public class ConcreateProduct1 implements Product {

	@Override
	public void show() {
		// TODO Auto-generated method stub
		System.out.println("This is Product1111 show");
	}

}

package factory1;

public class ConcreateProduct2 implements Product {

	@Override
	public void show() {
		// TODO Auto-generated method stub
		System.out.println("This is Product2222 show");
	}

}

抽象工厂模式

抽象工厂在于产品族的扩展
工厂方法是只有一种产品族的抽象工厂
在这里插入图片描述

package abstractFactory;

public interface Shape {
	public void draw();
}

package abstractFactory;

public class Circle implements Shape {

	@Override
	public void draw() {
		// TODO Auto-generated method stub
		System.out.println("画一个圆");
	}

}

package abstractFactory;

public class Rectangle implements Shape {

	@Override
	public void draw() {
		// TODO Auto-generated method stub
		System.out.println("画一个矩形");
	}

}


package abstractFactory;

public class Square implements Shape {

	@Override
	public void draw() {
		// TODO Auto-generated method stub
		System.out.println("画一个正方形");
	}

}

package abstractFactory;

public interface Color {
	public void draw();
}


package abstractFactory;

public class Bule implements Color {

	@Override
	public void draw() {
		// TODO Auto-generated method stub
		System.out.println("涂蓝色");
	}

}

package abstractFactory;

public class Green implements Color {

	@Override
	public void draw() {
		// TODO Auto-generated method stub
		System.out.println("涂绿色");
	}

}


package abstractFactory;

public class Red implements Color {

	@Override
	public void draw() {
		// TODO Auto-generated method stub
		System.out.println("涂红色");
	}

}

package abstractFactory;

public class ShapeFactory implements AbstractFactory {

	@Override
	public Color getColor(String color) {
		// TODO Auto-generated method stub
		return null;
	}


	@Override
	public Shape getShape(String shape) {
		// TODO Auto-generated method stub
		Shape sh=null;
		String pn = ShapeFactory.class.getPackageName();
		StringBuilder sb = new StringBuilder();
		sb.append(pn);
		sb.append(".");
		sb.append(Character.toUpperCase(shape.charAt(0)));
		sb.append(shape.substring(1).toLowerCase());
		try {
			sh=(Shape) Class.forName(sb.toString()).newInstance();
		} catch (InstantiationException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		return sh;
	}
}


package abstractFactory;

public class ColorFactory implements AbstractFactory {
	public Color getColor(String color) {
		Color cl=null;
		String pn = ColorFactory.class.getPackageName();
		StringBuilder sb = new StringBuilder();
		sb.append(pn);
		sb.append(".");
		sb.append(Character.toUpperCase(color.charAt(0)));
		sb.append(color.substring(1).toLowerCase());
		try {
			cl=(Color) Class.forName(sb.toString()).newInstance();
		} catch (InstantiationException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		return cl;
	}

	@Override
	public Shape getShape(String shape) {
		// TODO Auto-generated method stub
		return null;
	}
}


package abstractFactory;

public interface AbstractFactory {
	public Shape getShape(String shape);
	public Color getColor(String color);
}


package abstractFactory;

public class FactoryProducer {
	public static AbstractFactory getFactory(String which) {
		AbstractFactory af=null;
		String pn = FactoryProducer.class.getPackageName();
		StringBuilder sb = new StringBuilder();
		sb.append(pn);
		sb.append(".");
		sb.append(which);
		try {
			af = (AbstractFactory) Class.forName(sb.toString()).newInstance();
		} catch (InstantiationException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return af;
	}
}


package abstractFactory;

public class Client {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String[] shapes = {"circle","square","RECTANGLE"};
		String[] colors = {"bule","red","GREEN"};
		String[] factory = {"ShapeFactory","ColorFactory"};
		for(String f : factory) {
			AbstractFactory af = FactoryProducer.getFactory(f);
			for(String c : colors) {
				if(af.getColor(c)!=null) {
					af.getColor(c).draw();
				}
			}
			for(String s : shapes) {
				if(af.getShape(s)!=null) {
					af.getShape(s).draw();
				}
			}
		}
	}

}

总结

  • 简单工厂：把对象的创建放到一个工厂类中，通过参数来创建不同的对象。这个缺点是每添一个对象，就需要对简单工厂进行修改（尽管不是删代码，仅仅是添一个switch case，但仍然违背了“开闭”原则。
  • 工厂方法：每种产品由一种工厂来创建，是将创建对象的逻辑与任务交给工厂类，如果增加一个具体的产品，不用像简单工厂方法那样修改里面的代码，可以直接扩展，遵循 “开闭”原则
  • 抽象工厂：是工厂方法模式的进一步推广化和抽象化，扩充和升级，在抽象工厂模式中抽象产品可能是一个或者多个，从而构成了一个或多个产品族，只有一个产品族的抽象工厂模式就是工厂方法模式，一般是大项目用。
Vue JSX 快速上手指南【语法篇】
Dreamy_LIN的博客
12-30 2849
在 Javascript 里写 XML，同时拥有 Javascript 的灵活性和 HTML 的语义化。
jsx （vue3项目中使用）
m0_63304840的博客
03-08 5995
jsx在vue3项目中的使用
什么是Vue的JSX语法？如何使用JSX语法？
IT徐师兄
06-12 2431
JSX是一种JavaScript的语法扩展，它可以让我们在JavaScript代码中编写类似于HTML的标记语言。在React中，我们通常使用JSX语法来编写组件的模板。Vue也支持使用JSX语法来编写组件。JSX语法更加灵活，可以在JavaScript代码中直接使用JavaScript表达式。JSX语法更加直观，可以更容易地理解组件的结构和行为。JSX语法更加易于扩展，可以使用各种JavaScript库和框架来扩展其功能。
如何在 Vue 项目的 template 中使用 JSX
最新发布
油墨香^-^的博客
10-10 455
Vue项目JSX使用指南 JSX是JavaScript的语法扩展，允许在JS中编写类似HTML的标记。本文介绍了在Vue中使用JSX的完整方案： 配置步骤：安装Babel插件并配置babel.config.js 基础语法：组件结构、属性绑定、条件渲染（三元运算符和逻辑与） 高级用法：列表渲染、事件处理、插槽使用（具名插槽和作用域插槽） Vue3组合式API与JSX结合使用 最佳实践：性能优化、代码组织、注意事项 JSX优势包括更灵活的JS表达能力、更好的类型支持、直观的条件渲染和组件组合能力。配置时需注意B
在Vue 中使用 JSX 语法
dreamingbaobei的博客
04-17 5388
在Vue 中使用 JSX 语法
Vue中的jsx语法`
Oliver_web的博客
05-30 584
1.    
【Vue进阶】手把手教你在 Vue 中使用 JSX
iwen08的博客
12-18 2343
JSX是一种Javascript的语法扩展，，即在Javascript里面写XML，因为JSX的这个特性，所以他即具备了Javascript的灵活性，同时又兼具html的语义化和直观性有时候，我们使用渲染函数（）来抽象组件，渲染函数不是很清楚的参见这显然是吃力不讨好的，这个时候就派上 JSX 上场了。在 Vue 中使用 JSX，需要使用 Babel，它可以让我们回到更接近于模板的语法上，接下来就让我们一起开始在 Vue 中写 JSX 吧快读使用 vue-cli 创建一个 Vue 项目：配置。
vue 的jsx语法
newway007的博客
12-14 414
<script> const grids = new Array(8).fill(1).map((_, r) => { return new Array(8).fill(1).map((_, c) => { return { key: `key-${r * 8 + c}`, ok: false }; }); }); export default { name: "app", data.
在vue中使用jsx
weixin_47450807的博客
02-15 1万+
以前我们经常在react中使用jsx，现在我们在vue中也是用jsx,本文将总结一下，jsx在vue中是如何使用的。 一、安装babel插件 在之前我们需要安装@vue/babel-plugin-jsx,然后在babel.config.js中进行配置相关的文件内容。 module.exports = { plugins:[ "@vue/babel-plugin-jsx" ] } 现在的vue脚手架内置这些插件，所以可以直接编写jsx代码。 二、jsx实现计数器案例 此时是不是有一点react那味
详解如何使用webpack在vue项目中写jsx语法
11-27
在Vue项目中使用jsx语法，主要是借助Webpack的配置和Babel插件的转换能力。Vue 2.0虽然原生不支持JSX，但由于其强大的虚拟DOM机制，开发者可以选择使用jsx来编写组件的渲染逻辑。jsx是一种在JavaScript中插入XML语法...
详解Vue如何支持JSX语法
10-19
在Vue组件中使用JSX语法，需要引入Vue的渲染函数`createElement`，该函数通常被别名为`h`。这是Vue生态系统中的一个约定俗成的惯例，而且是JSX语法本身的要求。开发者需要在作用域中保持`h`的可用，否则会导致编译...
在vue中使用jsx语法的使用方法
10-16
主要介绍了在vue中使用jsx语法的使用方法，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Vue 3.0中jsx语法的使用
01-21
Vue 3.0 正式发布了，喜大普奔:beaming_face_with_smiling_eyes:。新的语法又要学习一阵阵，不过需要在生产环境下大面积使用，可能需要等到它的周边工具：vuex，vue-router 等等全部升级完毕。 Vue 3.0 中尤大使用的了新的编译工具 vite，革了 webpack 的命:face_with_tears_of_joy:。尝试看了下文档，发现支持 jsx 语法，由于这段时间都是在使用 react 来开发项目，jsx 完全不同的体验，更加的纯粹与灵活。 项目创建 npm init vite-app vite-vue cd vite-vue npm install npm run dev 我们发现创建的目录解构很简单 使用 JSX Vue 3.0 直接支持
Vue中JSX应用详解及其优势
在 Vue 中引入和使用 JSX 的关键在于其作为一种简洁且易于理解的语法特性，尤其适用于组件化开发。Vue.js 的模板系统允许开发者使用 `<template>` 标签或者单文件组件来定义 HTML 结构，但随着项目规模的扩大，这些...
详细教会你在vue中写jsx
WEBYANGxw的博客
12-06 1万+
详细教会你在vue中写jsx
Vue中的JSX详解：从概念到实战
油墨香^-^的博客
02-28 5120
本文全面介绍了Vue中使用JSX的开发方法。主要内容包括：JSX基础概念与环境配置（Babel/TypeScript支持）、基本语法（属性绑定/事件处理）、条件渲染与列表渲染技巧、组件使用与插槽系统实现、高级模式（函数式组件/动态组件）以及性能优化策略。通过Todo应用等实战案例，展示了JSX在Vue开发中的灵活性与优势。文章强调JSX能提供更强的JavaScript表达能力，改善类型安全，并适合构建复杂动态组件，同时提供了从入门到进阶的系统性指导，帮助开发者提升Vue项目的代码质量和开发效率。
vue中使用jsx语法
qq_42931285的博客
02-19 1006
vue中使用jsx语法
vue jsx语法配置和应用
好川的博客
11-27 4198
通过webpack构建配置jsx，通过vite构建的配置jsx
Vue中JSX的基本用法
热门推荐
CRMEB小程序商城的博客
06-08 2万+
首先需要约定一下，使用JSX组件命名采用首字母大写的驼峰命名方式，样式可以少的可以直接基于vue-styled-components写在同一个文件中，复杂的建议放在单独的_Styles.js_文件中，当然也可以不采用CSS-IN-JS的方式，使用Less/Sass来写，然后在文件中import进来。下面是一个通用的骨架： 插值 在JSX中使用单个括号来绑定文本插值 在jsx中不需要把分成事件绑定和赋值二部分分开来写，因为有相应的babel插件来专门处理。在JSX中可以直接使用来指定样式类，内联样式可以直接写
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值