php代码编程需要好习惯 优质代码

在上篇博文中,我们系统地讲述了策略模式,策略模式整体来说应该比较简单,其思想也是很容易弄懂,今天我们再来学习下另外一个模式——适配器模式,适配器模式的定义:适配器模式将一个类的接口转换成客户希望的另外一个接口,使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。怎么来讲呢,其实理解它也不难,这个模式有点类似我们日常生活中的“翻译”角色,一般都有一个充当适配功能的角色,再明白一点就是:就是与笔记本电源适配器、手机充电器有点类似,好了,说了这些,下面试试几个有意思的代码吧,代码如下:

1)翻译实例

#ifndef __ADPATER__H
#define __ADPATER__H

#include <iostream>
#include <boost/smart_ptr.hpp>
using namespace std;
using namespace boost;

class Translator
{
    public:
        virtual void speaker() = 0;
};

class ChineseTranslator : public Translator
{
    public:
        void speaker()
        {
            cout<<"chinese speaker hello"<<endl;
        }
};
class JapanTranslator : public Translator
{
    public:
        void speaker()
        {
            cout<<"Japan speaker hello"<<endl;
        }
};
class AmericanTranslator : public Translator
{
    public:
        void speaker()
        {
            cout<<"American speaker hello"<<endl;
        }
};
template<class T>
class Speaker
{
    public:
        Speaker()
        {
            adeptee = shared_ptr<T>(new T());
        }
        void speaker()
        {
            adeptee->speaker();
        }
    private:
        shared_ptr<T> adeptee;
};
#endif
#include "Adapter.h"

int main()
{
    Speaker<ChineseTranslator> chineseTranslator;
    Speaker<JapanTranslator> japanTranslator;
    Speaker<AmericanTranslator> usTranslator;

    chineseTranslator.speaker();
    japanTranslator.speaker();
    usTranslator.speaker();
}

在目标对象中,有一个被称之为“翻译者”的对象,目标对象所有的操作都是以这个翻译者对象基础,写到这里,突然感觉感觉适配器模式有点像之前所说的策略模式,确实有点像,在这里要注意区分,在策略模式里是由用户选择算法,而在适配器里面不存在用户选算法的过程,而是将目标对象转为适配器对象的相关操作,好了,接下来,我们就来实现几个简单的算法题吧,(用两个stack来模拟一个队列和用两个队列来模拟一个stack),代码如下:

1)两个stack模拟一个queue

#ifndef __STACK_QUEUE__H
#define __STACK_QUEUE__H

#include <iostream>
#include <vector>
#include <stack>

using namespace std;

template<class T>
class StackQueue
{
    public:
        StackQueue()
        {
        }
        ~StackQueue(){}

        int size() const
        {
            return front.size() + end.size();
        }

        void enQueue(const T& element)
        {
            end.push(element);
        }

        T deQueue()
        {
            if(front.size() > 0)
            {
                T elem = front.top();
                front.pop();
                return elem;
            }
            else
            {
                while(end.size()>0)
                {
                    front.push(end.top());
                    end.pop();
                }
                T elem = front.top();
                front.pop();
                return elem;
            }
        }
        void showAll()
        {
            while(size() > 0)
            {
                cout<<deQueue()<<" ";
            }
            cout<<endl;
        }
    private:
        stack<T> front;
        stack<T> end;
};
#endif
#include "StackQueue.h"


int main()
{
    StackQueue<int> stackQueue;
    for(int i=1;i<=10;i++)
        stackQueue.enQueue(i);
    cout<<stackQueue.deQueue()<<endl;
    cout<<stackQueue.deQueue()<<endl;

    stackQueue.enQueue(100);
    stackQueue.enQueue(200);

    stackQueue.showAll();
    return 0;
}

测试结果:

1
2
3 4 5 6 7 8 9 10 100 200

2)两个队列模拟一个栈

#ifndef __QUEUE_STACK__H
#define __QUEUE_STACK__H

#include <iostream>
#include <vector>
#include <queue>
using namespace std;

template<class T>
class QueueStack
{
    public:
        QueueStack(){}
        ~QueueStack(){}
        int size()
        {
            return front.size() + end.size();
        }
        void push(T element)
        {
            while(end.size() > 0)
            {
                front.push(end.front());
                end.pop();
            }
            front.push(element);
        }

        T pop()
        {
            T elem;
            while(front.size() > 1)
            {
                end.push(front.front());
                front.pop();
            }

            if(front.size()==1)
            {
                elem = front.front();
                front.pop();
            }

            while(end.size() > 0)
            {
                front.push(end.front());
                end.pop();
            }
            return elem;
        }

        void showAll()
        {
            while(size() > 0)
            {
                cout<<pop()<<" ";
            }
            cout<<endl;
        }

    private:
        queue<T> front;
        queue<T> end;
};
#endif
#include "QueueStack.h"


int main()
{
    QueueStack<int> queueStack;
    for(int i=1;i<10;i++)
        queueStack.push(i);

    cout<<queueStack.pop()<<endl;
    cout<<queueStack.pop()<<endl;

    queueStack.push(100);
    queueStack.push(200);
    queueStack.showAll();
    return 0;
}

测试结果:

9
8
200 100 7 6 5 4 3 2 1


总结

        本篇博文主要分析了下设计模式中的适配器模式,这种模式其实就类似与一个转接口,所有的操作都会被其封装的目标对象代替之,这种模式最大的好处就是很好的实现了封装思想,并且在文章的后半部分我们实现了两个案例,都是比较简单的,其思想就采用了适配器模式,这部分内容还是很简单的,但是如果运用到实际的开发项目中,还得好好的思考下,好了,本篇博文到此结束,下篇博文我们继续分析设计模式之单例模式。

如果需要,请注明转载,多谢   

郑重声明:本站内容如果来自互联网及其他传播媒体,其版权均属原媒体及文章作者所有。转载目的在于传递更多信息及用于网络分享,并不代表本站赞同其观点和对其真实性负责,也不构成任何其他建议。