深入理解设计模式之工厂模式

在以前的生活中我们都知道，需要什么东西都得自给自足，非常不方便，随着社会和经济的发展，不同行业出现了一个一个的工厂，不仅解决了很多人的就业问题，而且让我们不再关注于制造所需方法本身，只需要告诉工厂，让工厂直接给你生产出来产品即可。

简单工厂模式

由一个工厂对象决定创造哪一种产品类的实例，我们用一段代码来讲述女娲造人的故事：

首先定义一个接口，即我们需要的产品：

public interface Human {
    //每个人种都有自己的肤色
   void getColor();
   //每个人种都有自己的语言
   void talk();
}

定义黄色人种：

public class YellowHuman implements Human{
    @Override
    public void getColor() {
        System.out.println("黄皮肤");
    }

    @Override
    public void talk() {
        System.out.println("中国话");
    }
}

定义黑色人种：

public class BlackHuman implements Human{
    @Override
    public void getColor() {
        System.out.println("黑皮肤");
    }

    @Override
    public void talk() {
        System.out.println("freeStyle");
    }
}

定义白色人种：

public class WhiteHuman implements Human{
    @Override
    public void getColor() {
        System.out.println("白皮肤");
    }

    @Override
    public void talk() {
        System.out.println("English");
    }
}

定义工厂类：

public class HumanFactory {
    public Human createHuman (Class<? extends Human> clazz) throws Exception{
        return clazz.newInstance();
    }
}

人种有了，八卦炉也有了，剩下的工作就是女娲采集黄土，然后命令八卦炉开始生产。

定义女娲测试类：

public class NvWa {
    public static void main(String[] args) {
        HumanFactory humanFactory = new HumanFactory();
        try {
            Human yellowHuman = humanFactory.createHuman(YellowHuman.class);
            Human blackHuman = humanFactory.createHuman(BlackHuman.class);
            Human whiteHuman = humanFactory.createHuman(WhiteHuman.class);
            yellowHuman.getColor();
            yellowHuman.talk();
            blackHuman.getColor();
            blackHuman.talk();
            whiteHuman.getColor();
            whiteHuman.talk();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

下面我们来看运行结果：

 工厂方法模式

定义一个创建对象的接口，让实现这个接口的类来决定实例化哪个类。在工厂方法模式中用户只需要关心所需产品对应的工厂，无需关心创建细节，而且加入新的产品时符合开闭原则。

来看代码，先创建HumanFactory接口：

public interface HumanFactory {
    Human createHuman();
}

再分别创建子工厂：

class YellowHumanFactory implements HumanFactory{
    @Override
    public Human createHuman() {
        return new YellowHuman();
    }
}

class BlackHumanFactory implements HumanFactory{
    @Override
    public Human createHuman() {
        return new BlackHuman();
    }
}

class WhiteHumanFactory implements HumanFactory{
    @Override
    public Human createHuman() {
        return new WhiteHuman();
    }
}

测试代码如下：

public class NvWa {
    public static void main(String[] args) {
        try {
            YellowHumanFactory factory = new YellowHumanFactory();
            Human yellowHuman = factory.createHuman();
            yellowHuman.getColor();
            yellowHuman.talk();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

抽象工厂模式

女娲看到大地上一边生机勃勃，到处都是自己造出来的人类，满心欢喜，可是过了一段时间之后，突然发觉自己造出来的人没有性格，没有感情，没有性别，于是就发动了大洪水，这就是大洪水与诺亚方舟的故事，只能重新再捏。

我们定义产品接口：

public interface Human {
    void getColor();
    void talk();
    void getSex();
}

定义产品抽象类：

public abstract class WhiteHuman implements Human{
    @Override
    public void getColor() {
        System.out.println("白皮肤");
    }

    @Override
    public void talk() {
        System.out.println("English");
    }
}

public abstract class YellowHuman implements Human{
    @Override
    public void getColor() {
        System.out.println("黄皮肤");
    }

    @Override
    public void talk() {
        System.out.println("中国话");
    }
}

public abstract class BlackHuman implements Human{
    @Override
    public void getColor() {
        System.out.println("黑皮肤");
    }

    @Override
    public void talk() {
        System.out.println("freeStyle");
    }
}

定义具体实现的子类：

class FemaleBlackHuman extends BlackHuman{
    @Override
    public void getSex() {
        System.out.println("female");
    }
}
class MaleBlackHuman extends BlackHuman{
    @Override
    public void getSex() {
        System.out.println("male");
    }
}

class FemaleWhiteHuman extends WhiteHuman{
    @Override
    public void getSex() {
        System.out.println("female");
    }
}
class MaleWhiteHuman extends WhiteHuman{
    @Override
    public void getSex() {
        System.out.println("male");
    }
}

class FemaleYellowHuman extends YellowHuman{
    @Override
    public void getSex() {
        System.out.println("female");
    }
}
class MaleYellowHuman extends YellowHuman{
    @Override
    public void getSex() {
        System.out.println("male");
    }
}

我们来定义工厂类：

public interface HumanFactory {
    Human createYellowHuman();
    Human createWhiteHuman();
    Human createBlackHuman();
}

工厂子类：

class FemaleHumanFactory implements HumanFactory{
    @Override
    public Human createYellowHuman() {
        return new FemaleYellowHuman();
    }

    @Override
    public Human createWhiteHuman() {
        return new FemaleWhiteHuman();
    }

    @Override
    public Human createBlackHuman() {
        return new FemaleBlackHuman();
    }
}

class MaleHumanFactory implements HumanFactory{
    @Override
    public Human createYellowHuman() {
        return new MaleYellowHuman();
    }

    @Override
    public Human createWhiteHuman() {
        return new MaleWhiteHuman();
    }

    @Override
    public Human createBlackHuman() {
        return new MaleBlackHuman();
    }
}

女娲重造人类：

public class NvWa {
    public static void main(String[] args) {
        //第一条生产线，女性生产线
        FemaleHumanFactory femaleHumanFactory = new FemaleHumanFactory();
        //第二条生产线，男性生产线
        MaleHumanFactory maleHumanFactory = new MaleHumanFactory();
        //生产线建立完毕，开始生产人了:
        Human femaleYellowHuman = femaleHumanFactory.createYellowHuman();
        Human maleYellowHuman = maleHumanFactory.createYellowHuman();
        //生产黄色女性
        femaleYellowHuman.talk();
        femaleYellowHuman.getColor();
        femaleYellowHuman.getSex();
        //生产黄色男性
        maleYellowHuman.talk();
        maleYellowHuman.getColor();
        maleYellowHuman.getSex();
    }
}

运行结果如下：

 最后我们来看一下类图：