大话设计模式4 简单工厂模式VS工厂模式

工厂模式：

与前面学习的简单工厂模式比起来，工厂模式更加符合开放封闭原则，新增对象类型是通过新增工厂类实现的，而非修改原有的工厂类。用一个简单的学雷锋的例子做对比。

package simpleFactoryVSFactory;

interface IXueLeiFeng {
    void sweep();
    void wash();
}

class Student implements IXueLeiFeng {
    @Override
    public void sweep() {
        // TODO Auto-generated method stub
        System.out.println("Student sweep");
    }
    @Override
    public void wash() {
        // TODO Auto-generated method stub
        System.out.println("Student wash");
    }
}

class Volunteer implements IXueLeiFeng {
    @Override
    public void sweep() {
        // TODO Auto-generated method stub
        System.out.println("Volunteer sweep");
    }
    @Override
    public void wash() {
        // TODO Auto-generated method stub
        System.out.println("Volunteer wash");
    }
}

public class SimpleFactory {
    public static IXueLeiFeng createLeiFeng(String name) {
        IXueLeiFeng instance;
        if (name.equals("student")) {
            instance = new Student();
        } else {
            instance = new Volunteer();
        }
        return instance;
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        IXueLeiFeng leiFengA = createLeiFeng("student");
        leiFengA.sweep();
        leiFengA.wash();

        IXueLeiFeng leiFengB = createLeiFeng("Not student");
        leiFengB.sweep();
        leiFengB.wash();
    }
}

工厂模式抽象出一个工厂接口，新增对象类型，只需要实现工厂接口，扩展即可。

package simpleFactoryVSFactory;

interface IFactory {
    IXueLeiFeng createLeiFeng();
}

class StudentFactory implements IFactory {
    @Override
    public IXueLeiFeng createLeiFeng() {
        // TODO Auto-generated method stub
        return new Student();
    }
}

class VolunteerFactory implements IFactory {
    @Override
    public IXueLeiFeng createLeiFeng() {
        // TODO Auto-generated method stub
        return new Volunteer();
    }
}

public class Factory {
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        IFactory iFactoryA = new StudentFactory();
        IXueLeiFeng leiFengA = iFactoryA.createLeiFeng();
        leiFengA.sweep();
        leiFengA.wash();

        IFactory iFactoryB = new VolunteerFactory();
        IXueLeiFeng leiFengB = iFactoryB.createLeiFeng();
        leiFengB.sweep();
        leiFengB.wash();
    }

}

Head first

工厂模式VS抽象工厂

在Head first中,工厂模式:是定义了一个抽象方法,让继承它的子类去实现,将类的实例化推迟到子类.

而抽象工厂：则是定义了一个接口，里面组合了一堆相关对象的创建的方法。

工厂的特点：都是用来封装对象的创建，帮助实现针对接口编程，而非针对实现编程。