工厂方法模式

//这是客户端,
public class Client {
	public static void main(String[] args) {
		// 客户端只需要传入需要的产品类型，就能得到对应的产品，用户不需要知道创建产品的细节
		Product product = SimpleFactory.create("A");
		// Product product = SimpleFactory.create("B");

		// 调用生成产品的显示价格方法
		product.showPrice();
	}
}

/**
 * 抽象产品角色
 * 
 * @author ICE_melt
 *
 */
interface Product {
	// 显示产品价格
	public void showPrice();
}

// 具体产品A
class ConcreateProductA implements Product {

	@Override
	public void showPrice() {
		System.out.println("这是A产品,价格为10RMB,很便宜");

	}
}

// 具体产品B
class ConcreateProductB implements Product {

	@Override
	public void showPrice() {
		System.out.println("这是B产品,价格为600RMB,很贵的");

	}
}

/**
 * 工厂角色（即普通类提供了创建其他类的方法）
 * 
 * @author ICE_melt
 *
 */
class SimpleFactory {
	/**
	 * 	简单工厂一般为静态方法，其内包含必要的逻辑判断，能够根据客户端的条件创建具体的产品对象
	 * <br><b>剖析：</b>
	 * <br>现在的产品都是基于<code>Product<code>接口的子类，如果增加产品，继承体系没有问题
	 * <br>但是工厂生成逻辑需要修改（增加if分支判断逻辑），这一点违背了“开放封闭原则”
	 */
	public static Product create(String type) {
		if ("A".equals(type)) {
			return new ConcreateProductA();
		} else if ("B".equals(type)) {
			return new ConcreateProductB();
		} else {
			new RuntimeException(type + "产品类型暂时不能生产，请联系生产厂商！");
		}
		return null;
	}
}

/**
 * 产品抽象
 * 
 * @author ICE_melt
 *
 */
public abstract class AbstractProduct {

	public AbstractProduct() {
	}

	// 所有产品都有对外展示的方法
	public abstract void display();

}

//产品--汽车
public class CarProduct extends AbstractProduct {

	@Override
	public void display() {
		System.out.println("我有四个轮子，在陆地上跑的飞快");

	}

}

//产品--飞机
public class AirplaneProduct extends AbstractProduct {

	@Override
	public void display() {
		System.out.println("我有两个机翼，能在天上飞");

	}

}

//产品--轮船
public class ShipProduct extends AbstractProduct {

	@Override
	public void display() {
		System.out.println("我在海里，速度很快");

	}

}

/**
 * 一个工厂接口，负责定义产品对象的生产
 * (工厂接口也可以用抽象方法实现)
 * @author ICE_melt
 *
 */
public interface IFactory {
	/*
	 * 
	 * 创建一个产品对象
	 */
	public AbstractProduct produceProduct();
}

//汽车工厂，生产汽车
public class CarFactory implements IFactory {

	@Override
	public AbstractProduct produceProduct() {
		return new CarProduct();
	}

}

//飞机工厂，生产飞机
public class AirplaneFactory implements IFactory {

	@Override
	public AbstractProduct produceProduct() {
		return new AirplaneProduct();
	}

}

//轮船工厂，生产轮船
public class ShipFactory implements IFactory {

	@Override
	public AbstractProduct produceProduct() {
		return new ShipProduct();
	}

}

/**
 * 客户端代码
 * @author ICE_melt
 *
 */
public class Client {
	
	public static void main(String[] args) {
		//这里可以将工厂类的全路径类名写到项目的配置文件里，并添加一个读取该配置的方法
		String factoryConfig = readConfig();
		IFactory factory;
		try {
			//客户端代码只与抽象工厂 和 抽象产品 这两个顶级接口耦合，
			//后台增加 一种新的产品的话，只需要同时增加 该产品的工厂类，
			//不需要修改任何已存在的代码
			factory = (IFactory)Class.forName(factoryConfig).newInstance();
			AbstractProduct product = factory.produceProduct();
			product.display();
		} catch (Exception e) {
			//异常处理
			e.printStackTrace();
		}
		
	}
	
	public static String readConfig(){
		//可以将工厂类名全路径写到配置文件里，这样客户端无需
		//更改代码，只需配置即可完成不用产品的的展示需求
		return "com.icemelt.designpattern.factorymethod.AirplaneFactory";
	}
}