Java软件设计模式24种（专题分析）： 第2种简单工厂模式

Java软件设计模式24种（专题分析）： 第2种简单工厂模式

本章前言:问题说明

本章前言:

在现实生活中社会分工越来越细，越来越专业化。各种产品有专门的工厂生产，彻底告别了自给自足的小农经济时代，这大大缩短了产品的生产周期，提高了生产效率。同样，在软件开发中能否做到软件对象的生产和使用相分离呢？能否在满足“开闭原则”的前提下，客户随意增删或改变对软件相关对象的使用呢？这就是本节要讨论的问题。

第一章:什么是工厂方法模式?

工厂方法模式,同样属于类的创建型模式又称为多态工厂模式.工厂方法模式的意义是:定义一个创建产品对象的工厂接口.将实际的创建工作推迟到子类当中.核心工厂类不再负责产品的创建.这样核心类成为一个抽象工厂角色.仅仅负责具体工厂子类必须实现的接口,这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品.

第二章:简单工厂案例举例

第一步:创建3个实例水果类(苹果类+香蕉类+梨子类)

1.苹果类

package simplefactory01;

import java.io.Serializable;

public class Apple implements Frult,Serializable{
	/**
	 * 采集苹果
	 */
	
	public void get() {
		System.out.println("采集苹果");
	}
}

2.香蕉类

package simplefactory01;

import java.io.Serializable;

public class Banana implements Frult,Serializable{
	/**
	 * 采集香蕉
	 */
	
	public void get() {
		System.out.println("采集香蕉");
	}

}

3.梨子类

package simplefactory01;

public class Pear implements Frult {

	@Override
	public void get() {
		System.out.println("采集梨子");
	}

}

第二步:创建一个水果工厂Frultfactory类

package simplefactory01;
//定义一个水果工厂,专门用来生产各种水果.
//一个工厂实体类
public class Frultfactory { //这里是动态的方法,不是静态的方法	
	//第3次:工厂创建对象方法升级(定义为统一的get方法)
	public static Frult getFrult(String type) throws Exception, IllegalAccessException {
		//根据传递进来的参数,来判断是一个什么具体的水果对象
		//equalsIgnoreCase判断两字符串忽略大小写是否相等
		if(type.equalsIgnoreCase("apple")) {
			//我们这样创建一个apple对象,其实和我们的new一个apple对象是一样的,所以我们还可以改进
			return Apple.class.newInstance();
		} else if(type.equalsIgnoreCase("banana")) {
			return Banana.class.newInstance();
		} else if(type.equalsIgnoreCase("pear")) {
			return Pear.class.newInstance();
		} else {
			System.out.println("找不到对应的实例化类");
			return null;
		}	
	}

}

第三步;创建主程序类,来启动测试程序

package simplefactory01;

/**
 * @author Angle
 */

public class MainClass {
	public static void main(String[] args) throws Exception {
		//第5种:升级工厂创建水果的方法之后,再来创建水果对象.
		Frult apple = Frultfactory.getFrult("apple");
		Frult banana = Frultfactory.getFrult("banana");
		Frult pear = Frultfactory.getFrult("pear");
		apple.get();
		banana.get();
		pear.get();
	}

}

第四步:简单工厂模式PS工厂方法模式优缺点

简单工厂模式:简单工厂模式虽然我们不需要对主程序进行很大的修改,但是一旦我们添加一个新的水果进来,我们就需要对我们的水果工厂进行相应的修改.这样就不符合软件设计中的关闭修改,开放扩展原则.

工厂方法模式:工厂方法模式的优点是不需要修改原来的代码.因为它把这个工厂定义为一个接口.而将实际的创建工作推迟到子类当中.也就是这个核心工厂类不再负责产品的创建.而是一个抽象工厂角色.

第三章:工厂方法模式-案例举例

第一步:创建核心抽象工厂类.

package simplefactory01;
//定义一个水果工厂,专门用来生产各种水果.
public interface Frultfactory {
	//在接口中定义获得水果的方法
	public Frult getFrult();

}

第二步:如果你要获得苹果.创建一个苹果工厂类,实现水果工厂接口.

代码如下:

package simplefactory01;

public class AppleFactory implements Frultfactory {

	@Override
	public Frult getFrult() {
		// TODO Auto-generated method stub
		//这个苹果工厂,负责生产苹果
		return new Apple();
	}
}

第三步:如果你要获得香蕉.创建一个香蕉.工厂类,实现水果工厂接口.

代码如下:

package simplefactory01;

public class BananaFactory implements Frultfactory {

	@Override
	public Frult getFrult() {
		// TODO Auto-generated method stub
		//这个香蕉工厂,负责生产香蕉
		return new Banana();
	}

}

第四步;测试能否拿到对于的苹果和香蕉对象

在主程序中，通过工厂，测试能否拿到对于的苹果和香蕉对象。具体代码如下：

package simplefactory01;

/**
 * @author Angle
 */

public class MainClass {
	public static void main(String[] args) throws Exception {
		//需求1:获得苹果实例对象
		//1.获得苹果工厂AppleFactory
		AppleFactory ff =new AppleFactory();
		//2.通过苹果工厂来获得苹果实例对象
		Frult apple = ff.getFrult();
		apple.get();


		//需求2:获得香蕉实例对象
		//1.获得香蕉工厂AppleFactory
		BananaFactory bf = new BananaFactory();
		//2.通过香蕉工厂来获得香蕉实例对象
		Frult banana = bf.getFrult();
		banana.get();
	
	}
}

测试成功。

第五步：设计的好处

我们总结上面的接口工厂设置方式，我们有以下好处。1.当我们下次需要创建得到其他水果对象的时候，我们不需要在去修改接口工厂，也不需要修改苹果工厂类，和香蕉工厂类，而我们只需要，在创建一个梨子普通类，然后创建一个；梨子工厂类。然后通过梨子工厂来创建梨子对象，就可以了。以后我们的程序中，一样可以通过梨子工厂类来得到我们需要的梨子对象，可以反复的使用梨子工厂创建梨子对象。

第一步：定义梨子实力类

package simplefactory01;

public class Pear implements Frult {

	@Override
	public void get() {
		System.out.println("采集梨子");
	}

}

第二步：定义梨子工厂对象类

package simplefactory01;

public class PearFactory implements Frultfactory{

	@Override
	public Frult getFrult() {
		//编写创建梨子实例对象的方法
		// TODO Auto-generated method stub
		return new Pear();
	}

}

第三步：主程序中测试得到梨子实例化对象

package simplefactory01;
/**
 * @author Angle
 */
public class MainClass {
	public static void main(String[] args) throws Exception {
		//需求1:获得苹果实例对象
		//1.获得苹果工厂AppleFactory
		AppleFactory ff =new AppleFactory();
		//2.通过苹果工厂来获得苹果实例对象
		Frult apple = ff.getFrult();
		apple.get();


		//需求2:获得香蕉实例对象
		//1.获得香蕉工厂AppleFactory
		BananaFactory bf = new BananaFactory();
		//2.通过香蕉工厂来获得香蕉实例对象
		Frult banana = bf.getFrult();
		banana.get();


		//需求3:获得梨子实例对象
		//1.获得梨子工厂PearFactory
		PearFactory pf = new PearFactory();
		//2.通过梨子工厂来获得梨子实例对象
		Frult pear = pf.getFrult();
		pear.get();

	}

}

测试成功，拿到了我们需要的梨子实例化对象。这样的设计模式，就符合我们的开闭原则的软件程序设计思想。

第四章:工厂方法模式中包含的角色及其职责

1/抽象工厂角色
工厂方法模式的核心，任何工厂类都必须实现这个接口。

2/具体工厂对象
具体工厂类是抽象工厂的一个实现，负责实例化产品对象。

3/抽象角色
工厂方法模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。

4/具体产品角色
工厂方法模式所创建的具体实例对象。

第五章:工厂方法模式和简单工厂模式比较

工厂方法模式和简单工厂模式在结构上的不同不是很明显，工厂方法类的核心是一个抽象工厂类（一个接口），而简单工厂模式把核心放在一个具体类上。

工厂方法模式之所以有一个别名叫多太性工厂模式，是因为具体工厂类都有共同的接口，或者有共同的抽象父类。

当系统扩展需要添加新的产品对象时，仅仅需要添加一个具体对象，以及一个具体工厂对象，原有工厂对象不需要进行任何修改，也不需要修改客户端，很好的符合开放-封闭原则。而简单工厂模式在添加新产品对象后不得不修改工厂方法，扩展性不好。

工厂方法模式退化后，又可以演变成简单工厂模式。