（4）设计模式方法-创建型设计模式--：简单工厂模式【【【工厂方法模式

本文链接：https://blog.csdn.net/appandroid/article/details/9390127

===============================================================

简单工厂模式别名：静态工厂方法模式

该案例有如下几个元素：

产品接口：

具体产品：

静态工厂类：

客户类：

代码如下：

产品接口：

package 创建型模式.简单工厂模式;

/**
 * 抽象汽车类
 * @author victor 
 *@time     2013---2013-7-20---上午10:05:30
 *@package     创建型模式.简单工厂模式
 */
public  abstract class Auto {
	//车型名称
	private String name;
	
	//抽象的工作方法
	abstract public void run();
	
	//获得车型名称的方法
	public String getName(){
		return name;
	}
	
	//设置车型名称方法
	public void setName(String name){
		this.name=name;
	}
}

具体产品类：

package 创建型模式.简单工厂模式;

public class Bus extends Auto {

	public Bus(){
		this.setName("巴士");
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("启动"+this.getName());
	}

}

package 创建型模式.简单工厂模式;

public class Car extends Auto {

	//构造方法
	public Car(){
		this.setName("轿车");
	}
	
	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("启动"+this.getName());
	}

}

package 创建型模式.简单工厂模式;

public class Truck extends Auto {
	
	public Truck(){
		this.setName("卡车");
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("启动"+this.getName());
	}

}

静态工厂类：

package 创建型模式.简单工厂模式;

import javax.management.RuntimeErrorException;

public class StaticFactory {
	/**
	 * 工厂方法
	 */
	/**
	 * 工厂方法
	 * @param 车型编号
	 * @return  具体车对象
	 */
	public static Auto createAuto(int autoId){
		switch (autoId) {
		case 1:
			return new Car();
		case 2:
			return new Truck();
		case 3:
			return new Bus();
		default:
			throw new RuntimeException("没有本类型的车");
		}
	}
}

客户类：

package 创建型模式.简单工厂模式;

public class Client {

	/**
	 * 简单工厂方法的优点：
	 * 用代码和具体使用的类耦合度降低
	 * 令 创建和使用的代码向分离，可以独立的变化，易于扩展
	 * 
	 * 缺点：
	 * 当产品类曾多时，工厂类只有一个，只能以不变应万变，这就是该模式的缺点
	 * 
	 * 
	 * 
	 */
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//调用静态工厂里的方法创建对象
		Auto auto=StaticFactory.createAuto(1);
		auto.run();
		Auto auto2=StaticFactory.createAuto(2);
		auto2.run();
		Auto auto3=StaticFactory.createAuto(3);
		auto3.run();
		
		
	}

}

========================================================================================================================================================================================================================================================================

工厂方法模式：

在工厂方法模式的实例中，Auto汽车抽象的代码并没有改变

package 创建型模式.工厂方法模式;

public abstract class Auto {
		//车型名称
		private String name;
		
		//抽象的工作方法
		abstract public void run();
		
		//获得车型名称的方法
		public String getName(){
			return name;
		}
		
		//设置车型名称方法
		public void setName(String name){
			this.name=name;
		}
}

package 创建型模式.工厂方法模式;

public class Truck extends Auto {

	public Truck(){
		this.setName("卡车");
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("启动"+this.getName());
	}

}

package 创建型模式.工厂方法模式;

public class Bus extends Auto {

	public Bus(){
		this.setName("汽车");
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("启动"+this.getName());
	}

}

package 创建型模式.工厂方法模式;


public class Car extends Auto {

	public Car(){
		this.setName("轿车");
	}
	
	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("启动"+this.getName());
	}

}

工厂的抽象层次代码：

package 创建型模式.工厂方法模式;

public  abstract class Factory {
	/**
	 * 抽象生产方法，将被子类重写，
	 * return Auto的子类实例
	 */
	abstract public Auto createAuto();
}

轿车工厂类：

package 创建型模式.工厂方法模式;



public class CarFactory extends Factory {

	/**
	 * 重写父类生产方法
	 */
	@Override
	public Auto createAuto() {
		// TODO Auto-generated method stub
		return new Car();
	}

}

package 创建型模式.工厂方法模式;

public class BusFactory extends Factory {

	@Override
	public Auto createAuto() {
		// TODO Auto-generated method stub
		return new Bus();
	}

}

package 创建型模式.工厂方法模式;

public class TruckFactory extends Factory {

	@Override
	public Auto createAuto() {
		// TODO Auto-generated method stub
		return new Truck();
	}

}

客户端：

package 创建型模式.工厂方法模式;

public class Client2 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//调用工厂方法创建不同的对象
		//创建变量，（使用抽象类描述，面向接口的编程）
		Factory factory;
		Auto auto;
		//创建Car
		factory=new CarFactory();//创
		auto=factory.createAuto();//创建
		auto.run();
		
		//创建Bus
		factory=new BusFactory();
		auto=factory.createAuto();
		auto.run();
		
		//创建Truck
		factory=new TruckFactory();
		auto=factory.createAuto();
		auto.run();
	}

}

oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo

下面在举个例子讲述工厂方法模式，：货物上架问题：

1。首先是一个货物抽象类：

有货物的名称，货物的宽度

package 创建型模式.工厂方法模式.货架;

public  abstract class Goods {

	//货物的名称，一厘米做单位
	private int width;
	private String name;
	public int getWidth() {
		return width;
	}
	public void setWidth(int width) {
		this.width = width;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}

	
}

2.然后又三个类，分别是货物类，电视，电话，床

package 创建型模式.工厂方法模式.货架;

public class Phone extends Goods{

	public Phone(){
		super();
		this.setName("电话机");
		this.setWidth(20);
	}
}

package 创建型模式.工厂方法模式.货架;

public class TV extends Goods {

	//构造方法
	public TV(){
		super();
		this.setName("电视机");
		this.setWidth(100);
	}
	
	

}

package 创建型模式.工厂方法模式.货架;

public class Bed extends Goods {

	
	public Bed(){
		super();
		this.setName("双人床");
		this.setWidth(300);
	}
}

3.此时是一个货架抽象类：

货架的最大宽度，货架的名称

package 创建型模式.工厂方法模式.货架;

public abstract class Shelf {

	private int maxWidth;//货架的宽度
	private String shelfname;//货架的名称
	public int getMaxWidth() {
		return maxWidth;
	}
	public void setMaxWidth(int maxWidth) {
		this.maxWidth = maxWidth;
	}
	public String getShelfname() {
		return shelfname;
	}
	public void setShelfname(String shelfname) {
		this.shelfname = shelfname;
	}
	
	public void put(Goods goods){
		System.out.println("将"+goods.getName()+"放入"+this.getShelfname());
	}
	
	
}

此类有两个子类：

大货架，小货架

package 创建型模式.工厂方法模式.货架;

public class BigShelf extends Shelf {

	public BigShelf(){
		super();
		this.setShelfname("大型货架类");
		this.setMaxWidth(200);
	}
}

package 创建型模式.工厂方法模式.货架;

public class SmallShelf extends Shelf {

	public SmallShelf(){
		super();
		this.setShelfname("小型货架类");
		this.setMaxWidth(90);
	}
}

4货架抽象工厂类：

package 创建型模式.工厂方法模式.货架;

public abstract class ShelfFactory {

	private int maxWidth;

	public int getMaxWidth() {
		return maxWidth;
	}

	public void setMaxWidth(int maxWidth) {
		this.maxWidth = maxWidth;
	}
	
	abstract public Shelf createShelf();
	
}

下面是两个实现类与生产的两种货架一一对应

小型货架工厂：

package 创建型模式.工厂方法模式.货架;

public class SmallShelfFacroty extends ShelfFactory {

	public SmallShelfFacroty(){
		super();
		this.setMaxWidth(new SmallShelf().getMaxWidth());
	}
	@Override
	public Shelf createShelf() {
		// TODO Auto-generated method stub
		return new SmallShelf();
	}

}

大型货架工厂

package 创建型模式.工厂方法模式.货架;

public class BigShelfFactory extends ShelfFactory {

	public BigShelfFactory(){
		super();
		this.setMaxWidth(new BigShelf().getMaxWidth());
	}
	@Override
	public Shelf createShelf() {
		// TODO Auto-generated method stub
		return new BigShelf();
	}

}

由于客户端使用这三个抽象层次时，会发现很麻烦，所有涉及一个助手类：

package 创建型模式.工厂方法模式.货架;

import java.util.ArrayList;
import java.util.List;



public class PlaceGoodsHelper {

	public synchronized static void placegoods(Goods goods){
		List<ShelfFactory> shelflist=new ArrayList<ShelfFactory>();
		
		shelflist.add(new SmallShelfFacroty());
		shelflist.add(new BigShelfFactory());
		
		
		//货架的变量
		Shelf rightshelf;
		
		for (ShelfFactory sf:shelflist) {
			//货架合适
			if (sf.getMaxWidth()>=goods.getWidth()) {
				//实例化特定的货架，放置货物
				try {
					rightshelf=sf.createShelf();
					rightshelf.put(goods);
					
					return;
				} catch (Exception e) {
					// TODO: handle exception
				}
			}
			throw new RuntimeException("么有找到合适的框架");
		}
	}
	
}

客户端类：

package 创建型模式.工厂方法模式.货架;

import java.util.ArrayList;
import java.util.List;

public class Client3 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		List<Goods> goodslist=new ArrayList<Goods>();
		goodslist.add(new TV());
		goodslist.add(new Phone());
		goodslist.add(new Bed());
		
		System.out.println("货物初始化完毕");
		
		for (Goods goods:goodslist) {
			try {
				PlaceGoodsHelper.placegoods(goods);
			} catch (Exception e) {
				// TODO: handle exception
			}
		}
		System.out.println("货物放置完毕");
	}

}

总结：

工厂方法模式是设计模式中应用最为广泛的模式之一。

工厂方法模式要解决的就是对象的创建时机问题，它提供了一种扩展的策略，这很好的符合了开放--封闭的原则。