『重构--改善既有代码的设计』读书笔记----Self Encapsulate Field

如果你直接访问一个字段，你就会和这个字段直接的耦合关系变得笨拙。也就是说当这个字段权限更改，或者名称更改之后你的客户端代码都需要做相应的改变，此时你可以为这个字段建立设值和取值函数并且只以这些函数来访问字段。

自古以来，面向对象关于字段访问就存在两个派系，其中一个派系认为，如果在该字段所在的类中，你就可以*访问他，不需要通过间接的函数来获得。另外一派认为，即使在这个类中你也应该只使用设值和取值函数来间接访问。

当然了，间接访问可以带来的额外好处就是你可以通过子类来覆写函数做到改变获取数据的途径。他还可以让你支持灵活的数据管理方式，比如延迟初始化等。直接访问变量的好处也有，就是可以让我们阅读代码的人给我们更加明确清晰的思路，不要追函数追到一般才发现这原来只是一个简单的取值函数，从而影响我们的判断。

在面对这种选择的时候，我支持作者的观点，我在该字段本类中我会优先去使用直接访问的形式，直到这种直接访问的形式给我带来麻烦的时候，此时我才会去选择改变才用间接访问的方式，这也是重构带给我们的魅力，他可以让我们*改变我们需要的方式。

如果你想访问超类中的一个字段，却又想在子类中对这个变量的访问改为一个计算后的值（或者针对那种简单的类型码判断，基类和子类返回不一样的类型码）这就是使用Self Encapsulate Filed的时候，字段自我封装只是第一步，完成自我封装之后，你可以在子类中根据自己的需要随意覆写取值/设值函数。

做法：

• 为待封装字段建立设值/取值函数。
• 找出该字段的所有引用点，将他们全部改为设值/取值函数。如果引用点要读取字段值，就将他改为调用取值函数。如果引用点要给字段，就将他改为设值函数。当然这里也有一个小技巧帮你可以更快更全的找到所有引用点，就是你通过对字段改名，借助编译器帮你找到所有这些引用点。
• 将该字段声明为private.
• 复查，确保找到所有引用点。
• 编译，测试。

例子：

class IntRange
{
    public:
        IntRange(int low, int high) :
            m_low(low),
            m_high(high)
        {
        }

        bool includes(int arg)
        {
            return arg >= m_low && arg <= m_high;
        }

        void grow(int factor)
        {
            m_high = m_high * factor;
        }
    private:
        int m_low;
        int m_high;
}

为了封装m_low和m_high我们定义取值/设值函数，并使用它们。

class IntRange
{
    public:
        IntRange(int low, int high) :
            m_low(low),
            m_high(high)
        {
        }

        bool includes(int arg)
        {
            return arg >= low() && arg <= high();
        }

        void grow(int factor)
        {
            m_high = m_high * factor;
        }

        virtual int low() const
        {
            return m_low;
        }

        virtual int high() const
        {
            return m_high;
        }
    private:
        int m_low;
        int m_high;
};

同时这里有一点需要注意的就是你的取值函数和设值函数如果是在构造函数中进行调用的你就需要注意，现在C++默认在构造函数中是不会呈现多态性的，也就是说如果你在基类的构造函数中放了一个虚函数，当你创建子类的时候，当进入到基类的构造函数的时候并不会去调用子类的虚函数，依然还是去调用基类的虚函数。

同时还需要注意的就是默认一般来说，设值函数被认同是在对象创建之后才使用的，所以初始化过程中的行为可能与设值函数行为不同，这种情况下，你要么就是在构造函数中直接访问字段，要么就是单独创建另一个初始化函数。

IntRange(int low, int high) :
    m_low(low),
    m_high(high)
{
    initialize(low, high);
}

void initialize(int low, int high)
{
    m_low = low;
    m_high = high;
}

当然，现在你也许看不到什么价值，但如果你一旦拥有了子类，上述体现的价值就出来了。

class CappedRange : public IntRange
{
    public:
        CappedRange(int low, int high, int cap) :
            IntRange(low, high),
            m_cap(cap)
    {
    }

        virtual int cap() const
        {
            return m_cap;
        }

        virtual int high() const
        {
            return qMin(IntRange::high(), cap());
        }

    private:
        int m_cap;
};

现在你可以在high()中进行覆写，从而加上范围上限的考虑而不必修改IntRange的任何行为。