抽象工厂模式：这个模式我总是感觉和builder模式非常相似。
工厂方法模式提供的是对一个产品的等级模式，，而抽象工厂方法提供的是对多个产品的等级模式，注意，这里的多个具体产品之间是相互耦合的，也就是说这里的抽象工厂提供的产品之间是存在某种联系的。
有人做如下的比较：
工厂方法模式：一个抽象产品类，可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类只能创建一个具体产品类的实例。
抽象工厂模式：多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类可以创建多个具体产品类的实例。
区别：工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。
工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。
工厂方法模式：一个抽象产品类，可以派生出多个具体产品类。一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类只能创建一个具体产品类的实例。
抽象工厂模式：多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类可以创建多个具体产品类的实例。
Java工厂模式可分为三种：1.静态工厂模式
2.工厂方法模式
3.抽象工厂模式
一、静态工厂模式：用静态的方法实现，其创建的对象具有一定的特性
举例如下：
Vehicle类：
public abstract class Vehicle
{
private String name
public Vehicle (){
super()
}
public Vehicle (String name){
super()
this.name=name
}
public abstract void run()
public String getName(){
return name
}
public void setName(String name){
this.name=name
}
}
Bus类：
public class Bus extends Vehicle
{
private String name
public Bus(){}
public Bus(String name){
super(name)
}
@Override
public abstract void run(){
System.out.println("Bus is running")
}
}
Car类：
public class Car extends Vehicle
{
private String name
public Car(){}
public Car(String name){
super(name)
}
@Override
public abstract void run(){
System.out.println("Car is running")
}
}
静态工厂类：
（静态工厂创建一个对象，
静态工厂创建的对象一般都有一个共同的特性，
继承自某一个类，
或者引用一个接口）
public class StaticFactory{
public static Object getInstance(String className){
Object instance=null
try{
Class c=Class.forName(className)
instance=c.newInstance()
}catch(Exception e){}
return instance
}
public static Object getInstance(String className,Object ...args){
Class c=null
try{
c=Class.forName(className)
}catch(Exception e){}
Constructor[] cons=c.getConstructors()
Object instance=null
for(Constructor con:cons){
Class<?>[] cs=con.getParmeterTypes()
if(cs.length>0){
boolean isConstructor=true
for(int i=0i<cs.lengthi++){
Class t=cs[i]
if(!t.isInstance(args[i])){
isConstructor=false
}
}
if(isConstructor){
try{
instance=con.newInstance(args)
break
}catch(Exception e){}
}else{
continue
}
}
}
return instance
}
}
二、工厂方法模式：主要是对各类东西分类生产，但分类生产的对象仍然具有某一特性。
如果说静态工厂是一个综合的交通工具建造工厂，
那么工厂方法模式就是具体分工，分成Bus与Car的工厂，
各自生产各自的产品，但是造出来的还是交通工具。
交通工具制造接口：
public interface VehicleMake{
/**制造交通工具**/
public Vehicle make()
}
Bus制造类：
public class BusMake implements VehicleMake{
@Override
public Vehicle make(){
Vehicle bus=new Bus()
System.out.println("Bus工厂制造了一辆Bus")
return bus
}
}
Car制造类：
public class CarMake implements VehicleMake{
@Override
public Vehicle make(){
Vehicle car=new Car()
System.out.println("Car工厂制造了一辆Car")
return car
}
}
三、抽象工厂模式：抽象工厂生产的对象可能是没有共同特性的。比如，一个制造工厂BusMake不仅能制造Bus还能生产轮胎wheel等配件，Bus是交通工具，wheel是配件（代码中有部分类没具体写出来只给了类名）
总工厂（抽象工厂总接口）：
public interface WheelVehicleMake extends VehicleMake{
/**制造轮胎**/
public Wheel makeWheel()
}
轮子BusMake：
public class WheelBusMake implements WheelVehicleMake{
@Override
public Vehicle make(){
Vehicle bus=new Bus()
System.out.println("WheelBusMake生产了一辆Bus")
return bus
}
@Override
public Wheel makeWheel(){
Wheel busWheel=new BusWheel()
System.out.println("WheelBusMake生产了一个Bus轮子")
return busWheel
}
}
轮子CarMake：
public class WheelCarMake implements WheelVehicleMake{
@Override
public Vehicle make(){
Vehicle car=new Car()
System.out.println("WheelCarMake生产了一辆Car")
return car
}
@Override
public Wheel makeWheel(){
Wheel carWheel=new CarWheel()
System.out.println("WheelCarMake生产了一个Car轮子")
return carWheel
}
}
