3.14 以子类取代类型码

【1】原代码

class Employee
{
public:
    const static int ENGINEER = 0;
    const static int SALESMAN = 1;
    const static int MANAGER = 2;

public:
    Employee();

    int payAmount()
    {   // 典型的switch语句案例。
        // 这里仅仅列出了一个函数的业务逻辑实现过程，实际中可能会有很多这样的函数，需要进行这样类似的条件判断
        switch (m_nType)
        {
        case ENGINEER:
            return m_monthlySalary;
        case SALESMAN:
            return m_monthlySalary + m_bonus;
        case MANAGER:
            return m_monthlySalary + m_commission;
        default:
            break;
        }
    }

private:
    int m_nType;
    int m_bonus;
    int m_commission;
    int m_monthlySalary;
};

【2】以子类取代类型码

Employee.h

#ifndef _EMPLOYEE_H
#define _EMPLOYEE_H

#include "EmployeeType.h"
class Employee
{
public:
    Employee(int nType);

    int getType();
    void setType(int nType);
    int payAmount();

private:
    EmployeeType *m_pType;
};
#endif

Employee.cpp

#include "Employee.h"

Employee::Employee(int nType)
{
    setType(nType);
}

int Employee::getType()
{
    return m_pType->getTypeCode();
}

void Employee::setType(int nType)
{
    m_pType = EmployeeType::newType(nType);
}

int Employee::payAmount()
{
    return m_pType->payAmount();
}

EmployeeType.h

#ifndef _EMPLOYEETYPE_H
#define _EMPLOYEETYPE_H

class EmployeeType
{
public:
    const static int ENGINEER = 0;
    const static int SALESMAN = 1;
    const static int MANAGER = 2;

public:
    EmployeeType();
    static EmployeeType* newType(int code);

    virtual int payAmount() = 0;
    virtual int getTypeCode() = 0;

public:
    int m_bonus;
    int m_commission;
    int m_monthlySalary;
};

#endif

EmpolyeeeType.cpp

#include "EmployeeType.h"
#include "Engineer.h"
#include "Manager.h"
#include "Salesman.h"

EmployeeType::EmployeeType()
    : m_bonus(1000)
    , m_commission(500)
    , m_monthlySalary(2000)
{}

EmployeeType* EmployeeType::newType(int code)
{
    switch (code)
    {
    case ENGINEER:
        return (new Engineer());
    case SALESMAN:
        return (new Salesman());
    case MANAGER:
        return (new Manager());
    default:
        return (new Engineer());
    }
}

Engineer.h

#ifndef _ENGINEER_H
#define _ENGINEER_H

#include "EmployeeType.h"
class Engineer : public EmployeeType
{
public:
    Engineer();
    int getTypeCode();
    int payAmount();
};

#endif

Engineer.cpp

include "Engineer.h"

Engineer::Engineer() : EmployeeType()
{}

int Engineer::getTypeCode()
{
    return ENGINEER;
}

int Engineer::payAmount()
{
    return m_monthlySalary;
}

Manager.h

#ifndef _MANAGER_H
#define _MANAGER_H

#include "EmployeeType.h"

class Manager : public EmployeeType
{
public:
    Manager();
    int getTypeCode();
    int payAmount();
};

#endif

Manager.cpp

#include "Manager.h"

Manager::Manager() : EmployeeType()
{}

int Manager::getTypeCode()
{
    return MANAGER;
}

int Manager::payAmount()
{
    return m_monthlySalary + m_commission;
}

Salesman.h

#ifndef _SALESAMAN_H
#define _SALESAMAN_H

#include "EmployeeType.h"

class Salesman : public EmployeeType
{
public:
    Salesman();
    int getTypeCode();
    int payAmount();
};

#endif

Salesman.cpp

#include "Salesman.h"

Salesman::Salesman() : EmployeeType()
{}

int Salesman::getTypeCode()
{
    return SALESMAN;
}

int Salesman::payAmount()
{
    return m_monthlySalary + m_bonus;
}

main.cpp

#include "Employee.h"

void main()
{
    Employee *pEngineer = new Employee(EmployeeType::ENGINEER);
    pEngineer->payAmount();
}

【3】总结

有一个不可变的类型码，它会影响类的行为。以子类取代这个类型码。

Good Good Study, Day Day Up.

顺序 选择 循环 总结