【技术分享】从Tensorflow源码中学习设计模式

cloud.tencent.com/developer/a…

总结

简单工厂模式：一个工厂类，一个产品抽象类。

简单工厂模式有唯一的工厂类，工厂类的创建方法根据传入的参数做if-else条件判断，决定最终创建什么样的产品对象。

工厂方法模式：多个工厂类，一个产品抽象类。

工厂方法模式由多个工厂类实现工厂接口，利用多态来创建不同的产品对象，从而避免了冗长的if-else条件判断。

抽象工厂模式：多个工厂类，多个产品抽象类。

抽象工厂模式把产品子类进行分组，同组中的不同产品由同一个工厂子类的不同方法负责创建，从而减少了工厂子类的数量。

正文

核心内容提炼自<程序员小灰>

Q：一般情况下怎么创建对象

A：直接new一个对象

Q：如果创建对象有一些初始化操作，在哪里实现？

A：写在构造函数里

class Mask {
public:
    Mask(){
        // 5行初始化代码
        // .....
    }
}

Q：如果初始化操作有100行，比如关联其他对象，查数据库，查配置文件，还写在构造函数里吗?

A: 写在构造函数里太冗长，不妨写一个特殊的类，工厂类，专门用于初始化

class MaskFactory {
public: 
    Mask createMask() {
        Mask mask = new Mask();
        // 100行初始化代码
        // .....
        return mask;
    }
}

Q: 如果Mask存在子类，怎么创建对象？

A: 将子类类型作为参数传给工厂，工厂里根据不同子类类型走进不同分支进行创建

这就是简单工厂模式

class HighEndMask::Mask {
public： 
    HighEndMask() {
        printf("我是高端口罩");
    }
}

class LowEndMask::Mask {
public：
    LowEndMask(){
        printf("我的低端口罩");
    }
}

class MaskFactory{
public:
    Mask createMask(String type) {
        Mask mask = null;
        if("高端口罩" == type){
            mask = new HighEndMask();
            // .....
            // HighEndMask的100行初始化代码
        }else if("低端口罩" == type){
            mask =  new LowEndMask();
            // .....
            // LowEndMask的100行初始化代码
        }
        return mask;
    }
}

int main(String[] args) {
        MaskFactory factory = new MaskFactory();
        Mask maskA = factory.createMask("高端口罩");
        Mask maskB = factory.createMask("低端口罩");
    }
}

Q: 增加新的口罩种类，就要在工厂中增加一条分支，不符合面向对象的开放-封闭原则，改怎么改进？

A：可以为每一个口罩子类创建对应的工厂子类，这些工厂子类分别实现抽象的工厂接口，利用动态多态实现

这就是工厂方法模式

class HighEndFactory::MaskFactory{
public:
    Mask createMask() {
        Mask mask =  new HighEndMask();
        // .....
        // HighEndMask的100行初始化代码
        return mask;
    }
}

class LowEndFactory::IMaskFactory{
public:
    Mask createMask() {
        Mask mask =  new LowEndMask();
        // .....
        //  LowEndMask的100行初始化代码
        return mask;
    }
}

int main(String[] args) {
        MaskFactory factoryA = new LowEndFactory();
        MaskFactory factoryB = new HighEndFactory();
        Mask maskA = factoryA.createMask();
        Mask maskB = factoryB.createMask();
}

Q: 每一个子类都建立一个工厂，这样实在太繁琐了

A：为了避免工厂子类越来越多，引入抽象工厂模式，对工厂子类进行抽象。把产品类分组，组内不同产品对应于同一工厂类的不同方法

这就是抽象工厂模式

//产品类代码
class LowEndMask::Mask {
    void showMask(){
        printf("我的低端口罩");
    }
}
class HighEndMask::Mask {
    void showMask() {
        printf("我是高端口罩");
    }
}

class LowEndProtectiveSuit::ProtectiveSuit {
    void showSuit() {
        println("我是低端防护服");
    }
}
class HighEndProtectiveSuit::ProtectiveSuit {
    void showSuit() {
        printf("我是高端防护服");
    }
}

//工厂类代码

class LowEndFactory::Factory {
    Mask createMask() {
        Mask mask =  new LowEndMask();
        // .....
        //  LowEndMask的100行初始化代码
        return mask;
    }

    ProtectiveSuit createSuit() {
        ProtectiveSuit suit =  new LowEndProtectiveSuit();
        // .....
        //  LowEndProtectiveSuit的100行初始化代码
        return suit;
    }
}

class HighEndFactory::IFactory {
    Mask createMask() {
        Mask mask =  new HighEndMask();
        // .....
        // HighEndMask的100行初始化代码
        return mask;
    }

    ProtectiveSuit createSuit() {
        ProtectiveSuit suit =  new HighEndProtectiveSuit();
        // .....
        //  HighEndProtectiveSuit的100行初始化代码
        return suit;
    }
}

//客户端代码
int main(String[] args) {
        Factory factoryA = new LowEndFactory();
        Factory factoryB = new HighEndFactory();
        
        //创建低端口罩
        Mask maskA = factoryA.createMask();
        //创建高端口罩
        Mask maskB = factoryB.createMask();
        //创建低端防护服
        ProtectiveSuit suitA = factoryA.createSuit();
        //创建高端防护服
        ProtectiveSuit suitB = factoryB.createSuit();

        maskA.showMask();
        maskB.showMask();
        suitA.showSuit();
        suitB.showSuit();
    }
}

设计模式之 “工厂模式”

【技术分享】从Tensorflow源码中学习设计模式

总结

正文