/** * 产品的抽象接口  人类 * @author liaowp * */public interface Human {        public void say();}/** * man  男人 * @author liaowp * */public class Man implements Human {    /* say method     * @see com.roc.factory.Human#say()     */    @Override    public void say() {        System.out.println("男人");    }}/**女人 * @author liaowp * */public class Woman implements Human {    /* say method     * @see com.roc.factory.Human#say()     */    @Override    public void say() {        System.out.println("女人");    }}/** * 简单工厂 * @author liaowp * */public class SampleFactory {    public static Human makeHuman(String type){        if(type.equals("man")){            Human man = new Man();            return man;        }else if(type.equals("womman")){            Human woman = new Woman();            return woman;        }else{            System.out.println("生产不出来");            return null;        }                }}/** * 简单工厂反射实现，实际中次方法最常用 * @author liaowp * */public class SampleFactory1 {    public static Human makeHuman(Class c){        Human human = null;        try {            human = (Human) Class.forName(c.getName()).newInstance();        } catch (InstantiationException e) {            // TODO Auto-generated catch block            System.out.println("不支持抽象类或接口");            e.printStackTrace();        } catch (IllegalAccessException e) {            // TODO Auto-generated catch block            e.printStackTrace();            System.out.println("没有足够权限，即不能访问私有对象");        } catch (ClassNotFoundException e) {            // TODO Auto-generated catch block            System.out.println("类不存在");            e.printStackTrace();        }            return human;    }}/** * 简单工厂测试 * @author liaowp * */public class Client {    public static void main(String[] args) {//        Human man = SampleFactory.makeHuman("man");//        man.say();//        Human womman = SampleFactory.makeHuman("womman");//        womman.say();//        Human test = SampleFactory.makeHuman("tttt");                Human man = SampleFactory1.makeHuman(Man.class);        man.say();        Human woman = SampleFactory1.makeHuman(Woman.class);        woman.say();    }}

//抽象产品角色public interface Moveable {    void run();}//具体产品角色public class Plane implements Moveable {    @Override    public void run() {        System.out.println("plane....");    }}public class Broom implements Moveable {    @Override    public void run() {        System.out.println("broom.....");    }}//抽象工厂public abstract class VehicleFactory {    abstract Moveable create();}//具体工厂public class PlaneFactory extends VehicleFactory{    public Moveable create() {        return new Plane();    }}public class BroomFactory extends VehicleFactory{    public Moveable create() {        return new Broom();    }}//测试类public class Test {    public static void main(String[] args) {        VehicleFactory factory = new BroomFactory();        Moveable m = factory.create();        m.run();    }}

  可以看出工厂方法的加入，使得对象的数量成倍增长。当产品种类非常多时，会出现大量的与之对应的工厂对象，这不是我们所希望的。因为如果不能避免这种情 况，可以考虑使用简单工厂模式与工厂方法模式相结合的方式来减少工厂类：即对于产品树上类似的种类（一般是树的叶子中互为兄弟的）使用简单工厂模式来实 现。

四、简单工厂和工厂方法模式的比较

工厂方法模式和简单工厂模式在定义上的不同是很明显的。工厂方法模式的核心是一个抽象工厂类,而不像简单工厂模式, 把核心放在一个实类上。工厂方法模式可以允许很多实的工厂类从抽象工厂类继承下来, 从而可以在实际上成为多个简单工厂模式的综合,从而推广了简单工厂模式。 
反过来讲,简单工厂模式是由工厂方法模式退化而来。设想如果我们非常确定一个系统只需要一个实的工厂类, 那么就不妨把抽象工厂类合并到实的工厂类中去。而这样一来,我们就退化到简单工厂模式了。

五、抽象工厂模式

//抽象工厂类public abstract class AbstractFactory {    public abstract Vehicle createVehicle();    public abstract Weapon createWeapon();    public abstract Food createFood();}//具体工厂类，其中Food,Vehicle，Weapon是抽象类，public class DefaultFactory extends AbstractFactory{    @Override    public Food createFood() {        return new Apple();    }    @Override    public Vehicle createVehicle() {        return new Car();    }    @Override    public Weapon createWeapon() {        return new AK47();    }}//测试类public class Test {    public static void main(String[] args) {        AbstractFactory f = new DefaultFactory();        Vehicle v = f.createVehicle();        v.run();        Weapon w = f.createWeapon();        w.shoot();        Food a = f.createFood();        a.printName();    }}

在抽象工厂模式中，抽象产品 (AbstractProduct) 可能是一个或多个，从而构成一个或多个产品族(Product Family)。 在只有一个产品族的情况下，抽象工厂模式实际上退化到工厂方法模式。