《重构：改善既有代码的设计》代码实践之第七章

在对象之间搬移特性

Move field：搬移字段
move method: 搬移方法
extract class: 类由于承担过多责任而变的臃肿不堪，将一部分责任分离出去
inline class:类太"不负责任"，将它融入另一个类中
hide delegate:一个类使用了另一个类，将这种关系隐藏起来
remove middle man: 解决隐藏委托而导致拥有者的接口经常变化的问题
introduce foreign method: 当不能访问某个类的源码，又想把其他责任移进这个不可修改的类时，如果想加入的只是一两个函数。
introduce local extension:当不能访问某个类的源码，又想把其他责任移进这个不可修改的类时，如果想加入的不止一两个函数。

1. 搬移函数 move method

名称：搬移函数 move method
概要：在该函数最常引用的类中建立一个有着类似行为的新函数。将旧函数编程一个单纯的委托函数，或是将旧函数完全移除。
动机：在程序中，有个函数与其所驻类之外的另一个类进行更多交流，调用后者，或者被后者调用。

做法：
- 检查源类中被源函数所使用的一切特性（包括字段和函数），考虑它们是否应该被搬移
- 检查源类的子类和超类，看看是否有该函数的其他声明。如果出现其他声明，可能无法进行搬移，除非目标类中也同样表现出多态性。
- 在目标类中声明这个函数
- 将源函数的代码复制到目标函数中。调整目标函数，使之能够正常运行。如果目标函数中使用了源类中的特性，你得决定如何从目标函数引用源对象。如果目标类中没有相应的引用机制，就把源对象的引用当作参数，传给新建立的目标函数。如果源函数中包含异常处理，你得判断逻辑上应该由哪个类来处理这个异常。如果由源类来负责，就把异常处理留在原地。
- 编译目标类
- 决定如何从源函数正确引用目标对象。如果有现成的字段或者函数能够取得目标对象，如果没有，就建立一个。如果还是不行，就在源类中新建一个字段来保存目标对象。
- 修改源函数，使之成为一个纯委托函数
- 编译，测试
- 决定是否删除源函数，或者将它作为一个委托函数保留下来。如果经常在源对象中引用目标函数，就将源函数作为委托函数保留下来会比较简单。
- 如果要移除源函数，请将源类中对源函数的所有调用，替换为对目标函数的调用。
- 编译，测试
代码演示

修改之前的代码：

///////////////////////////.h
#ifndef REFACTORMOVE_H
#define REFACTORMOVE_H

class AccountType
{
public:
    bool isPremium();
private:
    int m_type;
};
class Account
{
public:
   double overdraftCharge();
   double bankCharge();
private:
   AccountType m_type;
   int m_daysOverdrawn;
};


#endif // REFACTORMOVE_H



///////////////////////////.cpp
#include "RefactorMove.h"


double Account::overdraftCharge()
{
        if (isPremium())
    {
        double result = 10;
        if (m_daysOverdrawn> 7)
        {
            result += (m_daysOverdrawn- 7) * 0.85;
        }
        return result;
    }
    return daysOverdrawn* 1.75;    
}

double Account::bankCharge()
{
    double result = 4.5;
    if (m_daysOverdrawn > 0)
    {
        result += m_type.overdraftCharge(m_daysOverdrawn);
    }
    return result;
}

bool AccountType::isPremium()
{
    return m_type > 0;
}

由于每种账户都有自己的“透支金额计费规则”，所以要把overdraftCharge()搬移到AccountType类中。对于overdraftCharge()的每一个特性，都要考虑是否搬走。isPremium是AccountType类， result是临时变量，所以要搬移。由于m_daysOverdrawn不会随账户类型而变化，所以留下来。当使用源类的特性时，有四种选择，本例中选第4种。
1）将这个特性也移到目标类中
2）建立或使用一个从目标类到源类的引用关系
3）将源对象当作参数传给目标函数
4）如果所需特性是个变量，将它当作参数传给目标函数
修改之后的代码：

///////////////////////////.h
#ifndef REFACTORMOVE_H
#define REFACTORMOVE_H

class AccountType
{
public:
    bool isPremium();
    double overdraftCharge(int daysOverdrawn);
private:
    int m_type;
};
class Account
{
public:
//   double overdraftCharge();
   double bankCharge();
private:
   AccountType m_type;
   int m_daysOverdrawn;
};


#endif // REFACTORMOVE_H
///////////////////////////.cpp
#include "RefactorMove.h"


//double Account::overdraftCharge()
//{
//    return m_type.overdraftCharge(m_daysOverdrawn);
//}

double Account::bankCharge()
{
    double result = 4.5;
    if (m_daysOverdrawn > 0)
    {
        result += m_type.overdraftCharge(m_daysOverdrawn);
    }
    return result;
}

bool AccountType::isPremium()
{
    return m_type > 0;
}

double AccountType::overdraftCharge(int daysOverdrawn)
{
    if (isPremium())
    {
        double result = 10;
        if (daysOverdrawn > 7)
        {
            result += (daysOverdrawn - 7) * 0.85;
        }
        return result;
    }
    return daysOverdrawn* 1.75;
}

如果需要源类的多个特性，就要将源对象传给目标函数。如果目标函数需要太多的源类特性，就要进一步重构。

2. 搬移字段 move field

名称：搬移字段 move field
概要：在目标类新建一个字段，修改源字段的所有用户，令它们改用新字段。
动机：在程序中，有个字段被其所驻类之外的另一个类更多的用到。

做法：
- 如果字段的访问级别是public，使用encapsulate field将它封装起来
- 编译，测试
- 在目标类中建立与源字段相同的字段，并同时建立相应的设值/取值函数
- 编译目标类
- 决定如何从源函数正确引用目标对象。如果有现成的字段或者函数能够取得目标对象，如果没有，就建立一个。如果还是不行，就在源类中新建一个字段来保存目标对象。
- 删除源字段
- 将所有对源字段的引用替换为对某个目标函数的调用。如果需要读取该变量，调用目标类的取值函数。如果需要设置该变量，调用目标类的设值函数。
- 编译，测试
代码演示

修改之前的代码：

///////////////////////////.h
#ifndef REFACTORMOVE_H
#define REFACTORMOVE_H

class AccountType
{
public:
    bool isPremium();
    double overdraftCharge(int daysOverdrawn);
private:
    int m_type;
};
class Account
{
public:
//   double overdraftCharge();
   double bankCharge();
   double interestForAmount_days(double amount, int days);
private:
   AccountType m_type;
   int m_daysOverdrawn;
   double m_interestRate;
};


#endif // REFACTORMOVE_H



///////////////////////////.cpp
#include "RefactorMove.h"

double Account::interestForAmount_days(double amount, int days)
{
    return m_interestRate *amount * days / 365;
}

我想要把m_interestRate搬移到AccountType类中。
修改之后的代码：

///////////////////////////.h
#ifndef REFACTORMOVE_H
#define REFACTORMOVE_H

class AccountType
{
public:
    bool isPremium();
    double overdraftCharge(int daysOverdrawn);
    void SetInterestRate(double interestRate);
    double GetInterestRate();

private:
    int m_type;
    double m_interestRate;
};
class Account
{
public:
    //   double overdraftCharge();
    double bankCharge();
    double interestForAmount_days(double amount, int days);
private:
    AccountType m_type;
    int m_daysOverdrawn;
    //double m_interestRate;
};


#endif // REFACTORMOVE_H

///////////////////////////.cpp
double Account::interestForAmount_days(double amount, int days)
{
    return m_type.GetInterestRate() *amount * days / 365;
}
void AccountType::SetInterestRate(double interestRate)
{
    m_interestRate = interestRate;
}

double AccountType::GetInterestRate()
{
    return m_interestRate;
}

如果源类中有很多函数已经使用了m_interestRate，可以先运用self encapsulate field. 给m_interestRate增加取值/设值函数。

3. 提炼类 extract class

名称：提炼类 extract class
概要：建立一个新类，将相关的字段和函数从旧类搬移到新类。
动机：某个类做了应该由两个类做的事。或者开发后期出现的子类化方式，如果你发现子类化只影响类的部分特性，或者发现某些特性需要以一种方式来子类化，某些特性需要以另一种方式子类化，这就意味着你需要分解原来的类。

做法：
- 决定如何分解类所负的责任
- 建立一个新类，用以表现从旧类中分离出来的责任。如果旧类剩下的责任与旧类名称不符，为旧类更名。
- 建立“从旧类访问新类”的连接关系。有可能需要一个双向连接。但是在真正需要它之前，不要建立“从新类通往旧类”的连接。
- 对于你想搬移的每一个字段，运用move field搬移之。
- 每次搬移后，编译，测试
- 使用 move method将必要函数搬移到新类。先搬移较低层次函数（也就是“被其他函数调用”多于“调用其他函数”者），再搬移较高层函数
- 每次搬移后，编译，测试
- 检查，精简每个类的接口。如果你建立起双向连接，检查是否可以将它改为单向连接
- 决定是否公开新类。如果你需要公开它，就要决定让它成为引用对象还是不可变的值对象。
代码演示

修改之前的代码：

///////////////////////////.h
#ifndef REFACTORMOVE_H
#define REFACTORMOVE_H

class Person
{
public:
    QString GetName();
    QString GetTelephoneNumber();
    QString GetOfficeAreaCode();
    void SetOfficeAreaCode(QString officeAreaCode);
    QString GetOfficeNumber();
    void SetOfficeNumber(QString officeNumber);
private:
    QString m_Name;
    QString m_OfficeNumber;
    QString m_OfficeAreaCode;
};

#endif // REFACTORMOVE_H



///////////////////////////.cpp
#include "RefactorMove.h"

QString Person::GetName()
{
    return m_Name;
}

QString Person::GetTelephoneNumber()
{
    return "(" + m_OfficeAreaCode + ") " +m_OfficeNumber;
}

QString Person::GetOfficeAreaCode()
{
    return m_OfficeAreaCode;
}

void Person::SetOfficeAreaCode(QString officeAreaCode)
{
    m_OfficeAreaCode = officeAreaCode;
}

QString Person::GetOfficeNumber()
{
    return m_OfficeNumber;
}

void Person::SetOfficeNumber(QString officeNumber)
{
    m_OfficeNumber = officeNumber;
}

1）将与电话号码相关的行为分离到一个独立类中。定义TelephoneNumber类来管理电话号码。
2）使用move method 将相关函数移动到TelephoneNumber类
3）考虑TelephoneNumber类的公开性和访问方式
修改之后的代码：

///////////////////////////.h
#ifndef REFACTORMOVE_H
#define REFACTORMOVE_H

class TelephoneNumber
{
public:
    void SetAreaCode(QString areaCode);
    QString GetAreaCode();
    QString GetTelephoneNumber();
    QString GetNumber();
    void SetNumber(QString officeNumber);
private:
    QString m_AreaCode;
    QString m_Number;
};

class Person
{
public:
    QString GetName();

    QString GetOfficeAreaCode();
    void SetOfficeAreaCode(QString officeAreaCode);

private:
    QString m_Name;
    QString m_OfficeAreaCode;
    TelephoneNumber m_TelephoneNumber;
};


#endif // REFACTORMOVE_H

///////////////////////////.cpp
QString Person::GetName()
{
    return m_Name;
}

QString TelephoneNumber::GetTelephoneNumber()
{
    return "(" + m_AreaCode + ") " +m_Number;
}

QString Person::GetOfficeAreaCode()
{
    return m_TelephoneNumber.GetAreaCode();
}

void Person::SetOfficeAreaCode(QString officeAreaCode)
{
    m_TelephoneNumber.SetAreaCode(officeAreaCode);
}

QString TelephoneNumber::GetNumber()
{
    return m_Number;
}

void TelephoneNumber::SetNumber(QString officeNumber)
{
    m_Number = officeNumber;
}

《重构：改善既有代码的设计》代码实践 之 第七章

猜你喜欢

《重构：改善既有代码的设计》代码实践之第七章