《重构》- 在对象之间搬移特性

一. Move Method(搬移函数)

介绍

场景
你的程序中，有个函数与其所驻类之外的另一个类进行更多交流：调用后者，或被后者调用。
手法
在该函数最常引用的类中建立一个有着类似行为的新函数。将旧函数变成一个单纯的委托函数，或是将旧函数完全移除。

动机

“搬移函数”是重构理论的支柱，可以使系统中的类更简单。
如果一个类有太多行为，或如果一个类与另一个类有太多合作而形成高度耦合，我就会搬移函数。

范例

重构前

class Account {
  overdraftCharge() {
    if(this._type.isPremium()) {
      let result = 10
      if(this._daysOverdrawn > 7) {
        result += (this._daysOverdrawn -7) * 0.85
      }
      return result
    } else {
      return this._daysOverdrawn * 1.75
    }
  }

  bankCharge() {
    const result = 4.5 
    if(this._daysOverdrawn > 0) {
      result += this.overdraftCharge()
    }
    return result
  }
}

重构后

class Account {
  bankCharge() {
    const result = 4.5 
    if(this._daysOverdrawn > 0) {
      result += this._type.overdraftCharge(this._daysOverdrawn)
    }
    return result
  }
}

class AccountType {
  overdraftCharge(daysOverdrawn) {
    if(this.isPremium()) {
      let result = 10
      if(daysOverdrawn > 7) {
        result += (daysOverdrawn -7) * 0.85
      }
      return result
    } else {
      return daysOverdrawn * 1.75
    }
  }
}

如果被搬移函数调用了Account中的另一个函数，我就不能简单地处理。这种情况下必须将源对象传递给目标函数。

class AccountType {
  overdraftCharge(account) {
    if(this.isPremium()) {
      let result = 10
      if(account.getDaysOverdrawn() > 7) {
        result += (account.getDaysOverdrawn() -7) * 0.85
      }
      return result
    } else {
      return account.getDaysOverdrawn() * 1.75
    }
  }
}

二. Move Field(搬移字段)

介绍

场景
在你的程序中，某个字段被其所驻类之外的另一个类更多地用到。
手法
在目标类新建一个字段，修改源字段的所有用户，令他们改用新字段。

动机

在类之间移动状态和行为，是重构过程中必不可少的措施。
使用Extract Class(提炼类)时，我也可能需要搬移字段。此时我会先搬移字段，然后再搬移函数。

范例

搬移只有一个函数使用的字段

重构前

class Account {
  _type: AccountType;
  _interestRate: number;

  interestForAmount_days(amount, days) {
    return this._interestRate * amount * days / 365
  }
}

重构后

class Account {
  _type: AccountType;

  interestForAmount_days(amount, days) {
    return this._type.getInterestRate() * amount * days / 365
  }
}

class AccountType {
  _interestRate: number;

  setInterestRate(arg) {
    this._interestRate = arg
  }

  getInterestRate() {
    return this._interestRate
  }
}

搬移有多个函数使用的字段

重构前

class Account {
  _interestRate: number;
  _type: AccountType;

  interestForAmount_days(amount, days) {
    return this.getInterestRate() * amount * days / 365
  }

  getInterestRate() {
    return this._interestRate
  }

  setInterestRate(arg) {
    this._interestRate = arg
  }
}

重构后

class Account {
  _type: AccountType;

  interestForAmount_days(amount, days) {
    return this.getInterestRate() * amount * days / 365
  }

  getInterestRate() {
    return this._type.getInterestRate()
  }

  setInterestRate(arg) {
    this._type.setInterestRate(arg)
  }
}

class AccountType {
  _interestRate: number;
  
  setInterestRate(arg) {
    this._interestRate = arg
  }

  getInterestRate() {
    return this._interestRate
  }
}

三. Extract Class(提炼类)

介绍

场景
某个类做了应该由两个类做的事。
手法
建立一个新类，将相关的字段和函数从旧类搬移到新类。

动机

一个类应该是一个清楚的抽象，处理一些明确的责任。
给类添加一项新责任时，你会觉得不值得为这项责任分离出一个单独的类。随着责任不断增加，这个类会变得过分复杂，成为一团乱麻。
如果某些数据和某些函数总是一起出现，某些数据经常同时变化甚至彼此相依，这就表示你应该将他们分离出去。

范例

重构前

class Person{
  _name: string;
  _officeAreaCode: string;
  _officeNumber: string;

  getName() {
    return this._name
  }

  getTelephoneNumber() {
    return `(${this._officeAreaCode})${this._officeNumber}`
  }

  getOfficeAreaCode() {
    return this._officeAreaCode
  }

  setOfficeAreaCode(arg) {
    this._officeAreaCode = arg
  }

  getOfficeNumber() {
    return this._officeNumber
  }

  setOfficeNumber(arg) {
    this._officeNumber = arg
  }
}

重构后

class Person {
  _name: string;
  _officeTelephone = new TelephoneNumber()

  getName() {
    return this._name
  }

  getTelephoneNumber() {
    return this._officeTelephone.getTelephoneNumber()
  }

  getOfficeTelephone() {
    return this._officeTelephone
  }
}

class TelephoneNumber {
  _areaCode: string;
  _number: string;

  getTelephoneNumber() {
    return `(${this._areaCode})${this._number}`
  }

  getAreaCode() {
    return this._areaCode
  }

  setAreaCode(arg) {
    this._areaCode = arg
  }

  getNumber() {
    return this._number
  }

  setNumber(arg) {
    this._number = arg
  }
}

四. Inline Class(将类内联化)

介绍

场景
某个类没有做太多事情。
手法
将这个类的所有特性搬移到另一个类中，然后移除原类。

动机

Inline Class(将类内联化)正好与Extract Class(提炼类)相反。
如果一个类不再承担足够责任、不再有单独存在的理由，我们就会挑选这一“萎缩类”的最频繁用户（也是个类），以Inline Class手法将“萎缩类”塞进另一个类中。

范例

重构前

class Person {
  _name: string;
  _officeTelephone = new TelephoneNumber()

  getName() {
    return this._name
  }

  getTelephoneNumber() {
    return this._officeTelephone.getTelephoneNumber()
  }

  getOfficeTelephone() {
    return this._officeTelephone
  }
}

class TelephoneNumber {
  _areaCode: string;
  _number: string;

  getTelephoneNumber() {
    return `(${this._areaCode})${this._number}`
  }

  getAreaCode() {
    return this._areaCode
  }

  setAreaCode(arg) {
    this._areaCode = arg
  }

  getNumber() {
    return this._number
  }

  setNumber(arg) {
    this._number = arg
  }
}

重构后

class Person{
  _name: string;
  _officeAreaCode: string;
  _officeNumber: string;

  getName() {
    return this._name
  }

  getTelephoneNumber() {
    return `(${this._officeAreaCode})${this._officeNumber}`
  }

  getOfficeAreaCode() {
    return this._officeAreaCode
  }

  setOfficeAreaCode(arg) {
    this._officeAreaCode = arg
  }

  getOfficeNumber() {
    return this._officeNumber
  }

  setOfficeNumber(arg) {
    this._officeNumber = arg
  }
}

五. Hide Delegate(隐藏“委托关系”)

介绍

场景
客户通过一个委托类来调用另一个对象。
手法
在服务类上建立客户所需的所有函数，用以隐藏委托关系。

动机

“封装”即使不是对象的最关键特征，也是最关键特征之一。
“封装”意味每个对象都应该尽可能少了解系统的其他部分，一旦发生变化，需要了解这一变化的对象就会比较少。
隐藏“委托关系”，当委托关系发生变化时，变化也将被限制在服务对象中，不会波及客户。
一旦你对所有客户都隐藏了委托关系，就不再需要在服务对象的接口中公开被委托对象了。

范例

重构前

class Person {
  _department: Department;

  getDepartment() {
    return this._department
  }

  setDepartment(arg) {
    this._department = arg
  }
}

class Department {
  _chargeCode: string;
  _manager: Person;

  Department(manager) {
    this._manager = manager
  }

  getManager() {
    return this._manager
  }
}

const m = john.getDepartment().getManager()

重构后

class Person {
  _department: Department;

  getManager() {
    return this._department.getManager()
  }

  setDepartment(arg) {
    this._department = arg
  }
}

const m = john.getManager()

六. Remove Middle Man(移除中间人)

介绍

场景
某个类做了过多的简单委托动作。
手法
让客户直接调用受托类。

动机

“封装受委托对象”的代价就是：每当客户要使用受托类的新特性时，必须在服务类添加一个简单委托函数。
随着受托类特性越来越复杂，委托函数越来越多，服务类完全成了一个“中间人”，此时你就应该让客户直接调用受托类。
重构的意义就在于：你永远不必说对不起——只要把出问题的地方修补好就行了。

范例

重构前

class Person {
  _department: Department;

  getManager() {
    return this._department.getManager()
  }

  setDepartment(arg) {
    this._department = arg
  }
}

class Department {
  _chargeCode: string;
  _manager: Person;

  Department(manager) {
    this._manager = manager
  }

  getManager() {
    return this._manager
  }
}

const m = john.getManager()

重构后

class Person {
  _department: Department;

  getDepartment() {
    return this._department
  }

  setDepartment(arg) {
    this._department = arg
  }
}

const m = john.getDepartment().getManager()

七. Introduce Foreign Method(引入外加函数)

介绍

场景
你需要为提供服务的类增加一个函数，但你无法修改这个类。
手法
在客户类中建立一个函数，并以第一参数形式传入一个服务类实例。

范例

重构前

//创建一个日期的下一天
const newStart = new Date(date.getFullYear(), date.getMonth(), date.getDate() + 1)

重构后

const nextDay = (date) => {
  return new Date(date.getFullYear(), date.getMonth(), date.getDate() + 1)
}

const newStart = nextDay(date)

八. Introduce Local Extension(引入本地扩展)

介绍

场景
你需要为服务类提供一些额外函数，但你无法修改这个类。
手法
建立一个新类，使它包含这些额外函数。让这个扩展品成为源类的子类或包装类。

动机

你需要为提供服务的类增加多个函数，但你无法修改这个类。
你需要将这些函数组织在一起，放到一个合适的地方去。子类化(subclassing)和包装(wrapping)是两种常用的本地扩展。
本地扩展是一个独立的类，但也是被扩展类的子类型：它提供源类的一切特性，同时额外添加新特性。

范例

使用子类

class MfDateSub extends Date{
  nextDay() {
    return new Date(this.getFullYear(), this.getMonth(), this.getDate() + 1)
  }
}

const mySubDate = new MfDateSub(2018, 9, 10)
console.log(mySubDate.nextDay())

注释：该代码只是为了演示使用子类扩展方式的原理，运行会报错。
使用包装类

class MfDateWrap {
  constructor() {
    this._original = new Date(...arguments)
  }

  getFullYear() {
    return this._original.getFullYear()
  }

  getMonth() {
    return this._original.getMonth()
  }

  getDate() {
    return this._original.getDate()
  }

  nextDay() {
    return new Date(this.getFullYear(), this.getMonth(), this.getDate() + 1)
  }
}

const mfDateWrap = new MfDateWrap(2018, 9, 10)
console.log(mfDateWrap.nextDay())

注释：使用包装类时需要为原始类（Date）的所有函数提供委托函数，这里只展示了三个函数，其他函数的处理依此类推。

《重构》- 在对象之间搬移特性

一. Move Method(搬移函数)

介绍

动机

范例

二. Move Field(搬移字段)

介绍

动机

范例

三. Extract Class(提炼类)

介绍

动机

范例

四. Inline Class(将类内联化)

介绍

动机

范例

五. Hide Delegate(隐藏“委托关系”)

介绍

动机

范例

六. Remove Middle Man(移除中间人)

介绍

动机

范例

七. Introduce Foreign Method(引入外加函数)

介绍

范例

八. Introduce Local Extension(引入本地扩展)

介绍

动机

范例

你可能感兴趣的:(《重构》- 在对象之间搬移特性)