设计模式学习（二）——简单工厂模式、工厂模式、抽象工厂模式

最近抽时间将之前看过的“程序人生”公众号推送的一篇工厂模式的介绍进行了实践，为了加深自己理解，特将自己的学习理解记录于此。初识设计模式，就被设计模式的精妙深深吸引，感觉脱离设计模式的代码就失去了美丽。作为一个测试，平日写代码的机会肯定不如开发多，但是希望自己能通过努力逐步提升代码水平，有一天也能写出优美的代码。如果有对于工厂模式或其他设计模式感兴趣的朋友欢迎一起探讨。

一、简单工厂模式

定义：专门定义一个类用来创建其他类的实例，被创建的实例通常具有共同的父类。

场景一：恰巧今天，老大兴奋地在群里说，“我们组明年有三个校招妹子要加入，分别来自武汉科技大学、浙江大学、华东师范大学。她们平时在学校工作都很努力。组里的单身汉子们可以挑一个妹子，当她的导师，带领她一起学习，帮助她早日适应公司的节奏。”

下面就是简单工厂模式的代码：

1. 创建一个妹子基类

public abstract class BaseMZ {
    public abstract void self_introduce();
    public void work(){
        System.out.println("Work hard..");
    }
}

2. 创建妹子类型，可以用枚举

public enum MZType {
    WU_HAN_KE_JI,
    HUA_DONG_SHI_FAN,
    ZHE_JIANG
}

3. 创建妹子子类

public class WuHanKeJiMZ extends BaseMZ {
    @Override
    public void self_introduce() {
        System.out.println("I am from WuHanKeji University.");
    }
}

public class HuaDongShiFanMZ extends BaseMZ {
    @Override
    public void self_introduce() {
        System.out.println("I am from HuaDongShiFan University.");
    }
}

public class ZheJiangMZ extends BaseMZ {
    @Override
    public void self_introduce() {
        System.out.println("I am from ZheJiang University.");
    }
}

4. 创建“妹子工厂”

public class MZFactory {
    public static BaseMM createMZ(MZType mzType){
        switch(mzType){
        case WU_HAN_KE_JI:
            return new WuHanKeJiMZ();
        case HUA_DONG_SHI_FAN:
            return new HuaDongShiFanMZ();
        default:
        case ZHE_JIANG:
            return new ZheJiangMZ();
        }
    }
}

5. 创建程序执行类Main

public static void main(String[] args) {
        BaseMZ whkjMZ = MZFactory.createMZ(MZType.WU_HAN_KE_JI);
        BaseMZ hdsfMZ = MZFactory.createMZ(MZType.HUA_DONG_SHI_FAN);
        BaseMZ zjMZ = MZFactory.createMZ(MZType.ZHE_JIANG);
        whkjMZ.self_introduce();
        whkjMZ.work();
        hdsfMZ.self_introduce();
        hdsfMZ.work();
        zjMZ.self_introduce();
        zjMZ.work();
    }

6. 执行结果

可见，简单工厂模式可以根据不同的参数，来创建不同的实例对象，并且返回的是基类的引用，使得程序提高了一定的灵活性。

二、工厂模式

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

场景二：刚过了一天，老大又说，“又要进来一个清华大学的妹子啦，谁要带？”

如果还是使用简单工厂模式，那么我们不得不在MZType里再增加一个清华妹子，并且还要在switch里增加对清华妹子类型的判断。如果哪天又来了各种学校的妹子，我们还得重复同样的操作，程序将变得不那么灵活。这时候我们就可以考虑工厂模式。

下面就是工厂模式的代码：

1. 创建一个妹子基类，跟简单工厂模式相同

public abstract class BaseMZ {
    public abstract void self_introduce();
    public void work(){
        System.out.println("Work hard..");
    }
}

2. 创建妹子子类

public class QingHuaMZ extends BaseMZ {
    @Override
    public void self_introduce() {
        System.out.println("I am from QingHua University.");
    }
}

3. 创建“妹子工厂”接口

public interface IMZFactory {
    public BaseMZ createMZ();
}

4. 创建“妹子工厂”类

public class QingHuaMZFactory implements IMZFactory{
    @Override
    public BaseMZ createMZ() {
        return new QingHuaMZ();
    }
}

5. 创建程序执行类Main

public class Main {
    public static void main(String[] args) {
        BaseMZ qhMZ = new QingHuaMZFactory().createMZ(); 
        qhMZ.self_introduce();
        qhMZ.work();
    }
}

6. 执行结果

可见，与简单工厂模式相比，工厂模式提供了一个创建各个具体子类的接口，我们可以通过不同的子类工厂来创建不同的子类，再次增加了灵活性，将不同子类之间的关系进一步解耦。 

三、抽象工厂模式

定义：提供一个创建一系列相关或者相互依赖对象的接口，而无需指定他们具体的类.

场景三：又过了一天，老大又在群里说，“听她们的同学说，武汉科技大学的妹子前端技术好，浙江大学的妹子吉他弹的赞，华东师范大学的妹子人长得漂亮。”

这时候我们可能就需要创建一个与妹子相关的“妹子同学”类，我们可以在“妹子工厂”里声明这些相关的类，表明这些类之间的相关性，同时通过这个工厂可以制造这一系列相关类的具体实例。

下面就是抽象工厂模式的代码：

1. 创建一个妹子基类，跟前面相同

public abstract class BaseMZ {
    public abstract void self_introduce();
    public void work(){
        System.out.println("Work hard..");
    }
}

2. 创建各个妹子子类

public class HuaDongShiFanMZ extends BaseMZ {
    @Override
    public void self_introduce() {
        System.out.println("I am from HuaDongShiFan University.");
    }
}

public class ZheJiangMZ extends BaseMZ {
    @Override
    public void self_introduce() {
        System.out.println("I am from ZheJiang University.");
    }
}

3. 创建妹子同学接口

public interface IMZClassmates {
    public void giveComments();
}

4. 创建各个妹子同学类

public class HuaDongShiFanMZClassmates implements IMZClassmates {
    @Override
    public void giveComments() {
        System.out.println("Looks so beautiful.");    
    }
}

public class ZheJiangMZClassmates implements IMZClassmates{
    @Override
    public void giveComments() {
        System.out.println("Good at playing guitar.");
    }
}

5. 创建“妹子工厂”接口

public interface IMZFactory {
    public BaseMZ createMZ();
    public IMZClassmates createMZClassmates();
}

6. 创建各个“妹子工厂”

public class HuaDongShiFanMZFactory implements IMZFactory{
    @Override
    public BaseMZ createMZ() {
        return new HuaDongShiFanMZ();
    }
    @Override
    public IMZClassmates createMZClassmates() {
        return new HuaDongShiFanMZClassmates();
    }
}

public class ZheJiangMZFactory implements IMZFactory{
    @Override
    public BaseMZ createMZ() {
        return new ZheJiangMZ();
    }
    @Override
    public IMZClassmates createMZClassmates() {
        return new ZheJiangMZClassmates();
    }
} 

7. 创建程序执行类Main 

public class Main {

    public static void main(String[] args) {    
        HuaDongShiFanMZFactory huaDongShiFanMZFactory = new HuaDongShiFanMZFactory();
        BaseMZ hdsfMZ = huaDongShiFanMZFactory.createMZ();
        IMZClassmates hdsfMZClassmates = huaDongShiFanMZFactory.createMZClassmates();
        
        ZheJiangMZFactory zheJiangMZFactory = new ZheJiangMZFactory();
        BaseMZ zjMz = zheJiangMZFactory.createMZ();
        IMZClassmates zjMZClassmates = zheJiangMZFactory.createMZClassmates();
        
        hdsfMZ.self_introduce();
        hdsfMZ.work();
        hdsfMZClassmates.giveComments();
        
        zjMz.self_introduce();
        zjMz.work();
        zjMZClassmates.giveComments();
    }

}

8. 运行结果

 

 

总结

简单工厂模式：专门定义一个工厂类用来创建其他类的实例，在工厂create方法中会根据不同的参数类型去创建不同的类。

工厂模式：定义一个工厂接口，在实现该接口的各个工厂子类中创建各个不同类的实例。

抽象工厂模式：定义一个工厂接口，提供一系列相关的或相互依赖的类的创建方式。