黑马程序员-简单工厂模式，工厂模式

最新推荐文章于 2024-04-25 16:50:38 发布

最美下雨天

最新推荐文章于 2024-04-25 16:50:38 发布

阅读量963

点赞数

分类专栏： java设计模式文章标签： android 设计模式黑马程序员工厂模式软件开发

本文链接：https://blog.csdn.net/whitepony/article/details/23050095

版权

java设计模式专栏收录该内容

13 篇文章 0 订阅

订阅专栏

---------------------- <a href="http://www.itheima.com"target="blank">ASP.Net+Unity开发</a>、<a href="http://www.itheima.com"target="blank">.Net培训</a>、期待与您交流！ ----------------------

利用简单工厂模式进行修改：

简单工厂模式：往往有个工厂类，该类的职责是用于创建产品，创建的产品往往是抽象产品（各种产品的父类）。

先写一下简单工厂模式的代码：但感觉上面的代码跟老师讲的简单工厂模式的代码相同，

现附上简单工程代码

Caculator类：

package demo3;

import java.util.Scanner;

public class Caculator {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int result = 0;
		Scanner scanner = new Scanner(System.in);
		System.out.println("输入一个整数：");
		int number1 = scanner.nextInt();
		System.out.println("输入第二个整数：");
		int number2 = scanner.nextInt();
		System.out.println("输入一个操作数：1代表+，2代表-，3代表*，4代表/");
		int operator = scanner.nextInt();
		Operator factoryInstance = OperatorFactory.getResult(operator);
		result = factoryInstance.getresult(number1, number2);
		System.out.println(result);

	}

}

OperatorFactory 类：

package demo3;

public class OperatorFactory {
	public static Operator operator;

	public static Operator getResult(int type) {
		switch (type) {

		case 1:
			operator = new Add();
			break;
		case 2:
			operator = new Subtraction();
			break;
		case 3:
			operator = new Mutiplication();
			break;
		case 4:
			operator = new Division();
			break;
		}
		return operator;
	}

}

简单工厂实现了界面层与逻辑层的完全解耦，但是并没有真正做到开闭原则

工厂模式

工厂模式与简单工厂模式相比只是简单增加了几个工厂类，分别产生相应的工厂，再由相应的工厂产生相应的产品

工厂接口：FactoryInterface

package demo4;

public interface FactoryInterface {
	public Operator getInstance();

}

加法工厂

package demo4;

public class AddFactory implements FactoryInterface {

	@Override
	public Operator getInstance() {
		// TODO Auto-generated method stub
		return new Add();
	}

}

减法工厂

package demo4;

public class DivisionFactory implements FactoryInterface {

	@Override
	public Operator getInstance() {
		// TODO Auto-generated method stub
		return new Division();
	}

}

乘方工厂

package demo4;

public class MuiplicationFactory implements FactoryInterface {

	@Override
	public Operator getInstance() {
		// TODO Auto-generated method stub
		return new Mutiplication();
	}

}

除法工厂

package demo4;

public class SubtractionFactory implements FactoryInterface {

	@Override
	public Operator getInstance() {
		// TODO Auto-generated method stub
		return new Subtraction();
	}

}

创建工厂

package demo4;

public class CreateFactory {
	public static FactoryInterface createFactory(int type) {
		FactoryInterface fi = null;
		switch (type) {

		case 1:
			fi = new AddFactory();
			break;
		case 2:
			fi = new SubtractionFactory();
			break;
		case 3:
			fi = new MuiplicationFactory();
			break;
		case 4:
			fi = new DivisionFactory();
			break;
		}
		return fi;
	}

}

Caculator 类

package demo4;

import java.util.Scanner;

public class Caculator {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int result = 0;
		Scanner scanner = new Scanner(System.in);
		System.out.println("输入一个整数：");
		int number1 = scanner.nextInt();
		System.out.println("输入第二个整数：");
		int number2 = scanner.nextInt();
		System.out.println("输入一个操作数：1代表+，2代表-，3代表*，4代表/");
		int operator = scanner.nextInt();
		FactoryInterface fi = CreateFactory.createFactory(operator);
		Operator op = fi.getInstance();
		result = op.getresult(number1, number2);
		System.out.println(result);

	}

}

（上述方法其实已经是工厂模式+简单工厂模式）

另一种方式：（工厂模式+反射+配置文件）

此时不再需要CreatFactory类来进行判断（删除此类）

<?xml version="1.0" encoding="utf-8" standalone="no"?>
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
<properties>
<entry key="+">demo4.AddFactory</entry>
<entry key="-">demo4.SubtractionFactory</entry>
</properties>

Caculator1 类

package demo4;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.InvalidPropertiesFormatException;
import java.util.Properties;
import java.util.Scanner;
import java.util.Scanner;

public class Caculator1 {

	/**
	 * @param args
	 * @throws IOException
	 * @throws FileNotFoundException
	 * @throws InvalidPropertiesFormatException
	 */
	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		int result = 0;
		Scanner scanner = new Scanner(System.in);
		System.out.println("输入一个整数：");
		int number1 = scanner.nextInt();
		System.out.println("输入第二个整数：");
		int number2 = scanner.nextInt();
		System.out.println("输入一个操作数：1代表+，2代表-，3代表*，4代表/");
		String operator = scanner.next();
		Properties prop = new Properties();
		prop.loadFromXML(new FileInputStream(new File("config.xml")));
		String className = prop.getProperty(operator);
		Class c = Class.forName(className);
		Objectobj = (c.getClassLoader().loadClass(className)).newInstance();
		FactoryInterface fi = (FactoryInterface) obj;
		Operator op = fi.getInstance();
		result = op.getresult(number1, number2);
		System.out.println(result);

	}

}

总结：

以一个后花园种菜为列：

一开始只在后花园中种蔬菜的时候可以用简单工厂模式，由工厂负责生产具体的蔬菜类，但是如果后花园要引进水果类的时候，用简单工厂模式就行不通了，因此需要使用工厂模式，将产品类族分开。

简单工厂模式的优缺点：

优点：

简单工程模式能够根据外界给定的信息，决定究竟应该创建哪个具体类的对象，通过它，外界可以从直接创建具体产品对象的尴尬局面中摆脱出来，外界与具体类隔离开来，耦合性低，

明确区分了各自的职责和权力，有利于整个软件体系结构的优化。

缺点：工厂类集中了所有实例的创建逻辑，它所能创建的类只是事先考虑到的，如果需要添加新的类，就需要改变工厂类了（这个问题在工厂模式中将得到很好的解决）

应用场景：
工厂类负责创建的对象比较少

客户只知道传入了工厂类的参数，对于如何创建对象（逻辑）不关心。

最美下雨天

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员-简单工厂模式，工厂模式

---------------------- ASP.Net+Unity开发、<a href="http://www.itheima.com"target="blank">.Net培训、期待与您交流！ ---------------------- 利用简单工厂模式进行修改：简单工厂模式：往往有个工厂类，该类的职责是用于创建产品，创建的产品往往是抽象产品（各种产品的
复制链接

扫一扫

专栏目录