工厂方法模式

标签：工厂模式   对象   main   etc   client   一个   rate   new   product   

工厂模式定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

 
一：通用源码
 
step1：抽象产品类
 

public abstract class Product{
    //产品类的公共方法
    public void method1() {
        //业务逻辑
    }
    //抽象方法
    public abstract void method2();
}

 
step2：具体产品类
 

public class ConcreteProduct1 extends Product{
    public abstract void method2(); {
        //业务逻辑处理
    }
}

public class ConcreteProduct2 extends Product{
    public abstract void method2(); {
        //业务逻辑处理
    }
}

 
step3：抽象工厂类
 

public abstract class Creator{
    /**
     * 创建一个产品对象，其输入参数类型可以自行设置，通常为String、Enum、Class等，也可为空
     * @param c
     * @return
     */
    public abstract <T extends Product> T createProduct(Class<T> c);
}

具体如何产生一个产品的对象呢？有具体的工厂类实现。
 
step4：具体工厂类
 

public class ConcreteFactory extends Creator {

    @Override
    public <T extends Product> T createProduct(Class<T> c) {
        //定义一个生产的人种
        Product product = null;
        try {
            //产生一个人种
            product = (T)Class.forName(c.getName()).newInstance();
        } catch (Exception e) {
            //异常处理
        }

        return (T)product;
    }

}

 
step5：场景类
 

public class Client{
    public static void main(String[] args) {
        Creator creator = new ConcreteFactory();
        Product product = creator.createProduct(ConcreteProduct1.class);
        /*
         * 后续业务处理
         */
    }
}

 
二：使用女娲造人的例子，应用通用模板
 
step1：抽象产品类
 

public interface Human {
    //每个人种都有颜色
    public void getColor();

    //每个人种都会说话
    public void talk();
}

 
step2：具体产品类（这里只给出一个白色的人）
 

public class WhiteHuman implements Human {

    @Override
    public void getColor() {
        // TODO Auto-generated method stub
        System.out.println("我是白色儿的");
    }

    @Override
    public void talk() {
        // TODO Auto-generated method stub
        System.out.println("我说的话你听不懂，you know？");
    }

}

 
step3：抽象工厂类
 

//抽象人类创建工厂
public abstract class AbstractHumanFactory {
    //必须是Class类型，必须是Human的实现类
    public abstract <T extends Human> T createHuman(Class<T> c);
}

 
step4：具体工厂类
 

public class HumanFactory extends AbstractHumanFactory {

    @Override
    public <T extends Human> T createHuman(Class<T> c) {
        //定义一个生产的人种
        Human human = null;
        try {
            //产生一个人种
            human = (T)Class.forName(c.getName()).newInstance();
        } catch (Exception e) {
            System.out.println("人种生成错误");
        }

        return (T)human;
    }

}

 
step5：场景类
 

public class NvWa {
    //模拟女娲造人的过程
    public static void main(String[] args) {
        AbstractHumanFactory yinYangLu = new HumanFactory();
        //造个白色儿的
        Human wHuman = yinYangLu.createHuman(WhiteHuman.class);
        wHuman.getColor();
        wHuman.talk();
        //来个黑小子
        Human bHuman = yinYangLu.createHuman(BlackHuman.class);
        bHuman.getColor();
        bHuman.talk();
        //小麦色的亚洲宝宝
        Human yHuman = yinYangLu.createHuman(YellowHuman.class);
        yHuman.getColor();
        yHuman.talk();

    }
}

 
三：理解
 
工厂方法模式使用的比较频繁，他是典型的解耦框架。高层模块只需要知道产品的抽象类，其他的实现类都不用关心。符合迪米特法则，我不需要的就不要去交流；符合依赖倒置原则，只依赖产品类的抽象；符合里氏替换原则，使用产品子类替换产品父类。
 
四：写在后面
 
设计模式比较抽象，对现在还没工作的我来说的确有点难理解。我现在只能死记硬背，先能认出人家用的是那种设计模式。希望工作后的我能真正理解设计模式的精髓，掌握他的核心！

工厂方法模式

标签：工厂模式   对象   main   etc   client   一个   rate   new   product   

原文地址：http://blog.51cto.com/13416247/2299454