【设计模式】简单工厂模式+工厂方法模式+抽象工厂模式

前提导论

为了学习设计模式时便于理解，我将用基于农夫和他的村子与森林为背景环境，讲一个故事时，阐述一个设计模式，今天作为第一个，我希望讲一个非常常见的设计模式–工厂模式。

故事

这是一个美丽而又安静祥和的村庄，村里的人日出而作日落而息，村子里，农夫靠伐木和打猎为生，女人呢，额。。。。总之，大家过着幸福美满的生活。 赵四是村子里为数不多的勤奋刻苦却聪明的农夫，同样靠着伐木为生，但他凭着自己敏锐的商业嗅觉，使得自己成为了村子里有钱的富人。
有一天，赵四想，我现在有钱了，我得打造把金斧子和银斧子，放在家里以示自己的出身和现在的尊贵。那现在有三种方式来打造金斧子和银斧子：

• 第一、赵四自己有这种手艺，向首饰店借来了金斧子银斧子的模子，自己做；
• 第二、赵四听说街上有一家首饰店，于是赵四向这家店订制金斧子和银斧子；
• 第三、赵四听说镇上有一家超大的首饰店，它旗下有两家有名的工厂，一家专门打造金斧子，一家专门打造银斧子，赵四去这家店买需要的金斧子和银斧子就可以了；

故事讲到这，先告一段落，因为上面三种情况分别是不采用工厂模式、简单工厂模式和工厂方法模式。

不采用工厂模式

//造金斧子
public class GoldenAxe{
    public GoldenAxe(){
        System.out.println("打造金斧子");
    }
}
//造银斧子
public class SilverAxe{
    public SilverAxe(){
        System.out.println("打造银斧子");
    }
}
//靠赵四自己用模子自己打造金斧子和银斧子
public class ZhaoSi{
   public static void main(String[] args) {
       GoldenAxe ga = new GoldenAxe();
       SilverAxe sa = new SilverAxe();
   }
}

不采用工厂模式的缺点很明显，就是赵四打造金斧子和银斧子需要自己动手，也就是客户和产品之间的耦合度很高，不利于扩展。于是，简单工厂模式出现了。

简单工厂模式

public abstract class Axe{

} 
//造金斧子
public class GoldenAxe extends Axe{
    public GoldenAxe(){
        System.out.println("打造金斧子");
    }
}
//造银斧子
public class SilverAxe extends Axe{
    public SilverAxe(){
        System.out.println("打造银斧子");
    }
}
//街上的首饰店
public class Factory{
//根据赵四的要求类型定制金斧子还是银斧子
    public Axe createAxe(String type){
        if("金斧子".equals(type)){
            return new GoldenAxe();
        }else if("银斧子".equals(type)){
            return new SilverAxe();
        }
        return null;
    }
}
public class ZhaoSi{
   public static void main(String[] args) {
       Factory fc = new Factory();
       Axe ga = fc.createAxe("金斧子");
       Axe sa = fc.createAxe("银斧子");
   }
}

简单工厂模式（也叫静态工厂方法模式），相对于不采用工厂模式来说，客户只需要知道自己要什么产品，至于产品如何做就交给工厂了，然而简单工厂的问题在于没有符合“对扩展开放，对修改闭合”的设计原则。拿上面例子来说，如果赵四有一天说他想打造一把钻石斧子，那这家首饰店就手足无措了，因为这家工厂目前只会打造金斧子和银斧子，因为赵四的需求，这家工厂得找会打造钻石斧子的人来做，也就是createAxe方法内要多一种情况了。为了符合“对扩展开放，对修改闭合”的设计原则，出现了本文第二种工厂模式–工厂方法模式。

工厂方法模式

public abstract class Axe{

}
//造金斧子
public class GoldenAxe extends Axe{
    public GoldenAxe(){
        System.out.println("打造金斧子");
    }
}
//造银斧子
public class SilverAxe extends Axe{
    public SilverAxe(){
        System.out.println("打造银斧子");
    }
}
//镇上的首饰店
public interface Factory{
    public Axe createAxe();
}
//旗下一家打造金斧子的工厂
public class GoldenAxeFactory implements Factory{
    public  Axe createAxe(){
        return new GoldenAxe();
    }
}
//旗下另一家打造银斧子的工厂
public class SilverAxeFactory implements Factory{
    public Axe createAxe(){
        return new SilverAxe();
    }
}

//赵四向镇上首饰店下单买金斧子和银斧子，首饰店就会交给打造金斧子的工厂，和打造银斧子的工厂去分别造金斧子和银斧子
public class ZhaoSi{
    public static void main(String[] args) {
        Factory gafc = new GoldenAxeFactory();
        Axe ga = gafc.createAxe();
        Factory safc = new SilverAxeFactory();
        Axe sa = safc.createAxe();
    }
}

工厂方法模式去掉了简单工厂模式中工厂方法的静态属性，使得它可以被子类继承。这样在简单工厂模式里集中在工厂方法上的压力可以由工厂方法模式里不同的工厂子类来分担。到这里，貌似工厂模式差不多讲完了，然而并没有，因为，因为赵四有另一故事。

故事

赵四得到了通过镇上的首饰店买到了金斧子和银斧子，但是他又想干脆再买套金锤子，银锤子吧（伐木工暴发户的劣根性啊），这怎么搞呢？街上没有、镇上没有，这时赵四听说县里有家更大的首饰店，它旗下有两家工厂，一家打造金器，一家打造银器，每家工厂下都会打造斧子和锤子。赵四一听乐了，赶紧向这家店下订单了。
这就是在工厂方法模式上更加复杂化些的，抽象工厂模式啦。

抽象工厂模式

//斧子
public abstract class Axe{

}
//造金斧子
public class GoldenAxe extends Axe{
    public GoldenAxe(){
        System.out.println("打造金斧子");
    }
}
//造银斧子
public class SilverAxe extends Axe{
    public SilverAxe(){
        System.out.println("打造银斧子");
    }
}
//锤子
pulic abstract class Hammer{

}
//造金锤子
public class GoldenHammer extends Hammer{
    public GoldenHammer(){
        System.out.println("打造金锤子");
    }
}
//造银锤子
public class SilverHammer extends Hammer{
    public SilverHammer(){
        System.out.println("打造银锤子");
    }
}
//县里的首饰店
public interface Factory{
    public Axe createAxe();//造斧子
    public Hammer createHammer();//造锤子
}
//旗下的打造金器的工厂
public class GoldFactory implements Factory{

    @Override
    public Axe createAxe() {
        return new GoldenAxe();
    }

    @Override
    public Hammer createHammer() {
        return new GoldenHammer();
    }

}
//打造银器的工厂
public class SilverFactory implements Factory{

    @Override
    public Axe createAxe() {
        return new SilverAxe();
    }

    @Override
    public Hammer createHammer() {
        return new SilverHammer();
    }

}

public class ZhaoSi{
   public static void main(String[] args) {
       Factory gf = new GoldFactory();
       gf.createAxe();
       gf.createHammer();

       Factory sf = new SilverFactory();
       sf.createAxe();
       sf.createHammer();
   }
}

到此，抽象工厂模式出来了。比较抽象工厂模式和工厂方法模式，无非就是产品从单一到多类，像上面的故事，从斧子到锤子，然而每类产品又有多种具体品种，比如斧子有金斧子和银斧子，锤子有金锤子和银锤子，这个时候将其组合实现时，就需要一个大的工厂来具体实现，比如GoldFactory用来实现打造金器（金斧子和金锤子）。

故事结局

好啦，工厂模式中涉及到的几种模式就讲完了，我这边不在意工厂模式的理论细节，只是希望通过通俗易懂的故事看到各个模式的区别，从无到有，从单一到多样化，自己从代码中慢慢品味才能更好的体会这种模式的妙处。