design pattern - 简单工厂模式

开闭原则：OCP,open-closed principle

对修改关闭，对扩展开放。

设计模式是为了，降低耦合和提高程序的可维护性和可扩展性。

CHANGE带给我们的噩梦

面向基类编程。

1、简单工厂模式

简单工厂模式中，工厂负责生产的产品的抽象基类，也可以是接口

/**
 * abstract base class of car.工厂产品的抽象基类
 */
public abstract class Car {
	abstract void drive();
}

奔驰车的实现类

/**
 * BenzCar extends abstract base class Car
 */
class BenzCar extends Car {
	@Override
	void drive() {
		System.out.print("BenzCar");
	}
}

宝马车的实现类

class BMWCar extends Car {
	/**
	 * implement base abstract method drive.
	 * @author pingxm
	 * 	 
        */
	@Override
	void drive() {
		System.out.print("BMWCar");
	}
}

上面是工厂负责产生的对象（工厂产品）的结构

下面是工厂类：CarFactory.java

/**
 *  the factory that product Car
 */
public class CarFactory {
	public static Car createCar(String carName)
	{
		if("benz".equals(carName))
			return new BenzCar();
		if("BMW".equals(carName))
			return new BMWCar();
		return null;
	}
}

简单工厂模式的优点:

封装对象的创建过程，根据需要(carName)创建对象.降低client和产品的耦合
缺点:工厂和产品的依赖关系比较强,如果扩展Car,比如增加奥迪车,需要修改工厂类,增加if else，工厂不符合OCP

简单工厂模式的改进:

/**
 *  the factory that product Car
 */
public class CarFactory {
	
	/**
	 * @return Car
	 */
	public static Car createCar(String carType)
	{
		Car car = null;
		Class carClass = null ;
		try {
			carClass = Class.forName(carType);
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		catch (Exception e) {
			e.printStackTrace();
		}
		
		try {
                        //实际应用中可能不是简单的newInstance
                        //可以根据配置文件设置属性值，关系等
			car = (Car)carClass.newInstance();
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		return car;
	}
}

通过类名去加载具体类，这样就降低了工厂和具体实现类的耦合。

但是这样依然需要传入具体类的类名，依然存在依赖关系

我们可以使用配置文件来 配置 描述符和类的完全限定名，从而降低耦合

properties文件

benzCar = package.BenzCar

BMWCar = package.BMWCar