标签：abstract inf jpg from 程序 ret 通过 决定 print
【转】设计模式学习（二）——简单工厂模式、工厂模式、抽象工厂模式
最近抽时间将之前看过的“程序人生”公众号推送的一篇工厂模式的介绍进行了实践，为了加深自己理解，特将自己的学习理解记录于此。初识设计模式，就被设计模式的精妙深深吸引，感觉脱离设计模式的代码就失去了美丽。作为一个测试，平日写代码的机会肯定不如开发多，但是希望自己能通过努力逐步提升代码水平，有一天也能写出优美的代码。如果有对于工厂模式或其他设计模式感兴趣的朋友欢迎一起探讨。
定义：专门定义一个类用来创建其他类的实例，被创建的实例通常具有共同的父类。
场景一：恰巧今天，老大兴奋地在群里说，“我们组明年有三个校招妹子要加入，分别来自武汉科技大学、浙江大学、华东师范大学。她们平时在学校工作都很努力。组里的单身汉子们可以挑一个妹子，当她的导师，带领她一起学习，帮助她早日适应公司的节奏。”
下面就是简单工厂模式的代码：
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 {</span><span style="color: #0000ff">public</span> <span style="color: #0000ff">static</span> <span style="color: #0000ff">void</span><span style="color: #000000"> main(String[] args) { HuaDongShiFanMZFactory huaDongShiFanMZFactory </span>= <span style="color: #0000ff">new</span><span style="color: #000000"> HuaDongShiFanMZFactory(); BaseMZ hdsfMZ </span>=<span style="color: #000000"> huaDongShiFanMZFactory.createMZ(); IMZClassmates hdsfMZClassmates </span>=<span style="color: #000000"> huaDongShiFanMZFactory.createMZClassmates(); ZheJiangMZFactory zheJiangMZFactory </span>= <span style="color: #0000ff">new</span><span style="color: #000000"> ZheJiangMZFactory(); BaseMZ zjMz </span>=<span style="color: #000000"> zheJiangMZFactory.createMZ(); IMZClassmates zjMZClassmates </span>=<span style="color: #000000"> zheJiangMZFactory.createMZClassmates(); hdsfMZ.self_introduce(); hdsfMZ.work(); hdsfMZClassmates.giveComments(); zjMz.self_introduce(); zjMz.work(); zjMZClassmates.giveComments(); }}
8. 运行结果
?
简单工厂模式：专门定义一个工厂类用来创建其他类的实例，在工厂create方法中会根据不同的参数类型去创建不同的类。
工厂模式：定义一个工厂接口，在实现该接口的各个工厂子类中创建各个不同类的实例。
抽象工厂模式：定义一个工厂接口，提供一系列相关的或相互依赖的类的创建方式。
?
标签：abstract inf jpg from 程序 ret 通过 决定 print
原文地址：https://www.cnblogs.com/fuyouchen/p/10032696.html
