Java的几个工厂方法解析

Java工厂模式可分为三种：静态工厂模式、工厂方法模式、抽象工厂模式。

一、静态工厂模式：用静态的方法实现，其创建的对象具有一定的特性
举例如下：
Vehicle类：
/**
*@author written by zrq
**/
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");
    }
}

静态工厂类：（静态工厂创建一个对象，静态工厂创建的对象一般都有一个共同的特性，继承自某一个类，或者引用一个接口，如本例中的Bus与Car均继承自Vehicle类，同时这些类都是Object或Object的一个子类）

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=0;i<cs.length;i++){
                    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;
    }
}