java工厂方法模式

  想了很久，还是决定写设计模式这一个系列的文章。为什么呢？因为自己的现阶段对代码有了一定的功底，需要更上一层楼，这需要总结和提炼。所以想借编写设计模式这个系列的文章来让自己的编程水平有所沉淀。其实网上也有不少这方面的文章了，但正所谓“纸上得来终觉浅，绝知此事要躬行”。看着别人造轮子，自己也要动手才可以提高。希望自己可以完成这个系列的编写。给自己加油！

  java的设计模式有三大类：

创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

分成这几类的原因其实和我们分析出来这么多模式的道理一样，就是将知识做到区别开来。方便我们有一个结构化的概念吧。这篇文章先从工厂方法模式开始。

普通工厂模式

普通的工厂模式的过程就是首先不同的对象类实现的同一个接口，例如，我们每天上班前都要买早餐（公司提供早餐的除外哈）。男生吃的多，也比较喜欢吃粉之类的早餐。而女生都喜欢吃清淡点，比如豆浆包子。那这个接口就是买早餐。男生女生就是2个不同的对象类。好了， 等男生女生都去买早餐了以后呢。再建一个工厂类，对买早餐这个动作进行实现。其实可以把早餐店想成一个工厂类，男生的话，早餐店就给你肠粉，女生就给你豆浆包子，让你实现买早餐的这个事情。

好吧。我们先来写出买早餐这个接口吧。

public interface IBuyBreakfast {
    /**
     * 就是简简单单的买早餐的动作咯
     */
    void buyMyBreakfast();
}

然后是我们男生类的实现。

public class Man implements IBuyBreakfast{
    @Override
    /**
     * 男生买早餐
     */
    public void buyMyBreakfast() {
        System.out.println("买一份瘦肉加蛋的肠粉，5块");
    }
}

接下来就是女生类的实现。

public class Woman implements IBuyBreakfast{
    @Override
    /**
     * 女生买早餐
     */
    public void buyMyBreakfast() {
        System.out.println("买一份豆浆包子吧，女生吃的不多");
    }
}

好了。男生女生来买早餐了，我们把早餐店，也就是工厂类给实现吧。

public class BreakfastFactory {
    public IBuyBreakfast goToBuy(String typeOfpeople){
        if("man".equals(typeOfpeople)){
            return new Man();
        }else if("woman".equals(typeOfpeople)){
            return new Woman();
        }else{
            System.out.println("识别不了，谢谢");
            return null;
        }
    }
}

好了，正式开始买早餐！

public class BreakfastFactoryTest {
    public static void main(String[] args) {
        BreakfastFactory factory = new BreakfastFactory();
        //假如是男生买早餐，那就告诉店家我是一个man咯
        IBuyBreakfast iBuyBreakfast = factory.goToBuy("man");
        iBuyBreakfast.buyMyBreakfast();
    }
}

输出了：买一份瘦肉加蛋的肠粉，5块

买完早餐咯。

好了，这就是简单的工厂模式。

然而生活中总有一些逗比，不好好买早餐。不肯定告诉老板man还是woman。而是告诉老板，我是一个handsome man!这不，就出现了

public class BreakfastFactoryTest {
    public static void main(String[] args) {
        BreakfastFactory factory = new BreakfastFactory();
        //逗比会说自己是handsome man
        IBuyBreakfast iBuyBreakfast = factory.goToBuy("handsome man");
        iBuyBreakfast.buyMyBreakfast();
    }
}

结果输出：识别不了，谢谢
Exception in thread "main" java.lang.NullPointerException

at com.bluedon.mydesign.factory.BreakfastFactoryTest.main(BreakfastFactoryTest.java:8)

还报了空指针错。。。

好吧，这样我们就只好使出多个工厂模式方法。那怎么样是多个工厂模式呢？其实我们只需要对BreakfastFactory类进行修改就好了，怎么修改呢？之前我们是传入参数再根据参数来返回对象。那现在，我们就不接你的参数了，让你自己选择你想要的对象，也就是你想要的早餐。好，下面就是新的BreakfastFactory类。

public class BreakfastFactory {
    public IBuyBreakfast manGoToBuy(){
        return  new Man();
    }
    public IBuyBreakfast womanGoToBuy(){
        return  new Man();
    }
}

然后我们再看看那买早餐的整个过程。

public class BreakfastFactoryTest {
    public static void main(String[] args) {
        BreakfastFactory factory = new BreakfastFactory();
        IBuyBreakfast iBuyBreakfast = factory.manGoToBuy();
        iBuyBreakfast.buyMyBreakfast();
    }
}

这下子，不管你谁来，你就只能买男生或者女生的早餐了，不怕你说你是handsome man了，手动微笑.jpg。但是早餐店的老板有意见了，他说每次来人我都得备好男生或者女生的早餐，好累啊，能不能来人直接拿早餐，我也不和你创建对接的方式了？那好，静态工厂模式来了~

我们把工厂类的方法变成静态的。

public class BreakfastFactory {
    public static IBuyBreakfast manGoToBuy(){
        return  new Man();
    }
    public static IBuyBreakfast womanGoToBuy(){
        return  new Man();
    }
}

这样在买早餐的时候就可以直接调用了。

public class BreakfastFactoryTest {
    public static void main(String[] args) {
        IBuyBreakfast iBuyBreakfast = BreakfastFactory.manGoToBuy();
        iBuyBreakfast.buyMyBreakfast();
    }
}

这下老板省心了点。可是万一有人真的不合适男生和女生的早餐，比如小孩，他想喝粥呢？老板也会纳闷，我开门做生意，肯定谁的早餐都卖呀，可是又要回去改我的工厂类，也就是我组合早餐的方式。这样也好折腾呀。有没有不影响原来的卖早餐的方式呢？嘿嘿，有是有的，那就是抽象工厂模式。

什么是抽象工厂模式呢？其实就是一开始的时候，就把男生买早餐当做一个工厂类，把女生买早餐当做另外的一个工厂类。这样，有小孩的时候就再给小孩创建一个新的工厂类，这样也不会影响之前的男生和女生的工厂类了。那接下来，我们就看看怎么实现吧~

首先，新增了一个接口，这个接口很关键。理解明白这个接口很重要。

public interface IBreakfastType {
    public IBuyBreakfast giveBreakfast();
}

这个接口是干嘛的呢？我们先不着急理解它，先看它使用了IBuyBreakfast来定义了一个方法。我们再来看看IBuyBreakfast这个接口

public interface IBuyBreakfast {
    /**
     * 就是简简单单的买早餐的动作咯
     */
    void buyMyBreakfast();
}

然后我们来看看男生和女生的2个工厂类：

public class ManFactory implements IBreakfastType{
    @Override
    public IBuyBreakfast giveBreakfast() {
        return new Man();
    }
}
public class WomanFactory implements IBreakfastType {
    @Override
    public IBuyBreakfast giveBreakfast() {
        return new Woman();
    }
}

在这2个工厂类都实现了IBreakfastType这个接口。

最后再看早餐店发生的这一切。

public class BreakfastFactoryTest {
    public static void main(String[] args) {
       IBreakfastType iBreakfastType = new WomanFactory();
       IBuyBreakfast iBuyBreakfast = iBreakfastType.giveBreakfast();
       iBuyBreakfast.buyMyBreakfast();
    }
}

那我们看到之前一直关注的IBreakfastType这个接口其实就是为了让我们可以直接创建出工厂类就可以完成买早餐的动作。

所以这就是抽象工厂模式，有了2个接口，让我们可以通过创建新的工厂类的模式来应对一切。

我们看看小孩的工厂类吧。也算课后实践。

先创建一个小孩类

public class Child implements  IBuyBreakfast {
    @Override
    public void buyMyBreakfast() {
        System.out.println("小孩喝点粥呗~");
    }
}

再就是小孩工厂类

public class ChildFactory implements  IBreakfastType {
    @Override
    public IBuyBreakfast giveBreakfast() {
        return  new Child();
    }
}

然后我们看看最后早餐店的改变

public class BreakfastFactoryTest {
    public static void main(String[] args) {
       IBreakfastType iBreakfastType = new ChildFactory();
       IBuyBreakfast iBuyBreakfast = iBreakfastType.giveBreakfast();
       iBuyBreakfast.buyMyBreakfast();
    }
}

只需要改变创建的工厂类就可以了，也就是把男生工厂类变成小孩工厂类。是不是很改变很小？哈哈，这也是体现了java设计模式的开闭原则。工厂模式就到这里了。谢谢大家！！！