工厂模式

通常来讲，工厂模式分为：简单工厂模式，工厂方法模式和抽象工厂模式。
简单工厂模式定义一个factory类，来根据要求，创建不同的对象。有人说这种模式当有了新一种产品的时候，就要修改factory类，违反了OCP原则。但我感觉如果client传递对应的class的话，可以避免这个弊端。例如：

public interface Product {

}

public class Bus implements Product {
public Bus(){

	System.out.println("This is a bus!");
}
}

public class Car implements Product {
	public Car() {
		System.out.println("This is a car!");
	}
}

工厂类：

public class SimpleFactory {
	public static Product factory(Class c) throws Exception  {
		return (Product) c.newInstance();
	}
}

测试类：

	public static void main(String[] args) throws Exception {
		// 简单工厂模式

		SimpleFactory.factory(Bus.class);
		SimpleFactory.factory(Car.class);}

这样即使增加一个其他的产品也只须定义一个产品类，并不需要修改simplefactory。
我认为，简单工厂模式是工厂方法模式的一个特殊情况，在必要的时候也可以据其要求，定义一个factory接口，然后由具体的产品factory来实现产品的创建。只是，我还并没有遇到过这种情况，毕竟有一种产品便要写一个对应的factory类，是一个让人感觉诡异的做法。
当产品分类多，且复杂的时候，宜使用抽象工厂模式，其好处是：

　1.系统不依赖于产品类实例如何被创建，组合和表达的细节。
　2.系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。
　3.同属于同一个产品族是在一起使用的。这一约束必须在系统的设计中体现出来。
　4.系统提供一个产品类的库，所有产品以同样的接口出现，从而使客户端不依赖于实现。


工厂方法模式针对的是一个产品等级结构；而抽象工厂模式针对的是多个产品等级结果。
　　
产品族：是指位于不同产品等级结构中，功能相关联的产品组成的家族。一般是位于不同的等级结构中的相同位置上。显然，每一个产品族中含有产品的数目，与产品等级结构的数目是相等的，形成一个二维的坐标系，水平坐标是产品等级结构，纵坐标是产品族。叫做相图。
　　当有多个不同的等级结构的产品时，如果使用工厂方法模式就势必要使用多个独立的工厂等级结构来对付这三个产品的等级结构。如果这些产品等级结构是平行的，会导致多个平行的工厂等级结构。

public interface AbstructCar {

}
public interface AbstructBus {

}
public class BusA implements AbstructBus {
	public BusA() {
		System.out.println("This is busA");
	}
}
public class BusB implements AbstructBus {
	public BusB() {
		System.out.println("This is busB");
	}
}

public class CarA implements AbstructCar {
	public CarA() {
		System.out.println("This is CarA");
	}
}
public class CarB implements AbstructCar {
	public CarB() {
		System.out.println("This is CarB");
	}
}

工厂：

public interface AbstructFactory {
	public AbstructBus createBus();
	public AbstructCar createCar();
}

public class FactoryA implements AbstructFactory{

	@Override
	public AbstructBus createBus() {
		return new BusA();
	}
	@Override
	public AbstructCar createCar() {
		return new CarA();
	}

}

public class FactoryB implements AbstructFactory {
	@Override
	public AbstructBus createBus() {
		return new BusB();
	}
	@Override
	public AbstructCar createCar() {
		return new CarB();
	}

}

测试：

public class Test {
	public static void main(String[] args) throws Exception {
		 AbstructFactory af = new FactoryA();
		 af.createBus();
		 af.createCar();
		 AbstructFactory aff = new FactoryB();
		 aff.createBus();
		 aff.createCar();
	}
}