kent.getCourses().remove(refact);
   Assert.equals(3, kent.getCourses().size());
如果想了解高级课程,可以这么做:
   Iterator iter = person.getCourses().iterator();
   int count = 0;
   while(iter.hasNext()) {
      Course each = (Course)iter.next();
      if(each.isAdvanced()) count++;
   }
我要做的第一件事就是为Person中的群集(collections)建立合适的修改函数(modifiers, 亦即add/remove函数),如下所示,然后编译:
class Person...
   public void addCourse(Course arg) {
      _courses.add(arg);
   }
   public void removeCourse(Course arg) {
      _courses.remove(arg);
   }
如果我想下面这样初始化_courses值域,我的人生会轻松得多:
   private Set _courses = new HashSet();

接下来我需要观察设值函数(setter)的调用者.如果有许多地点大量运用了设值函数,我就需要修改设值函数,令它调用添加/移除(add/remove)函数.这个过程的复杂度取决于设值函数的被使用方式.设值函数的用法有两种,最简单的情况就是:它被用来[对集群进行初始化动作].换句话说,设值函数被调用之前,_courses是个空群集.这种情况下我需要修改设值函数,令它调用添加函数(add)就行了:
class Person...
   public void setCourses(Set arg) {
      Assert.isTrue(_courses.isEmpty());
      Iterator iter = arg.iterator();
      while(iter.hasNext()) {
         addCourse((Course)iter.next());
      }
   }
修改完毕后,最后以Rename Method(273)更明确地展示这个函数的意图.
   public void initializeCourses(Set arg) {
      Assert.isTrue(_courses.isEmpty());
      Iterator iter = arg.iterator();
      while(iter.hasNext()) {
         addCourse((Course)iter.next());
      }
   }
更普通的情况下,我必须首先以移除函数(remove)将群集中的所有元素全部移除,然后再调用添加函数(add)将元素一一添加进去.不过我发现这种情况很少出现(唔,愈是普通的情况,愈少出现).

如果我知道初始化时,除了添加元素,不会再有其他行为,那么我可以不使用循环,直接调用addAll()函数:
   public void initializeCourses(Set arg) {
      Assert.isTrue(_courses.isEmpty());
      _courses.addAll(arg);
   }
我不能仅仅对这个set赋值,就算原本这个set是空的也不行.因为万一用户在[把set传递给Person对象]之后又去修改它,会破坏封装.我必须像上面那样创建set的一个拷贝.

如果用户仅仅只是创建一个set,然后使用设值函数(setter.译注:目前已改名为initializeCourses()),我可以让它们直接使用添加/移除(add/remove)函数,并将设值函数完全移除.于是,以下代码:
   Person kent = new Person();
   Set s = new HashSet();
   s.add(new Course("Smalltalk Programming", false));
   s.add(new Course("Appreciating Single Malts", true));
   kent.initializeCourses(s);
就变成了:
   Person kent = new Person();
   kent.addCourse(new Course("Smalltalk Programming", false));
   kent.addCourse(new Course("Appreciating Single Malts", true));


接下来我开始观察取值函数(getter)的使用情况.首先处理[有人以取值函数修改底部群集(underlying collection)]的情况,例如:
   kent.getCourses().add(new Course("Brutal Sarcasm", false));
这种情况下我必须加以改变,使它调用新的修改函数(modifier):
   kent.addCourse(new Course("Brutal Sarcasm", false));
修改完所有此类情况之后,我可以让取值函数(getter)返回一个只读映件(read-only view),用以确保没有任何一个用户能够通过取值函数(getter)修改群集:
   public Set getCourses() {
      return Collections.unmodifiableSet(_courses);
   }
这样我就完成了对群集的封装.此后,不通过Person提供的add/remove函数,谁也不能修改群集内的元素.

将行为移到这个class中

我拥有了合理的接口.现在开始观察取值函数(getter)的用户,从中找出应该属于Person的代码.下面这样的代码就应该搬移到Person去:
   Iterator iter = person.getCourses().iterator();
   int counter = 0;
   while(iter.hasNext())｛
      Course each = (Course)iter.next();
      if(each.isAdvanced()) cout++;
   }

因为以上只使用了属于Person的数据.首先我使用Extract Method(110)将这段代码提炼为一个独立函数:
   int numberOfAdvancedCourses(Person person) {
      Iterator iter = person.getCourses().iterator();
      int count = 0;
      while(iter.hasNext()) {
         Course each = (Course)iter.next();
         if(each.isAdvanced()) count++;
      }
      return count;
   }
然后使用Move Method(142)将这个函数搬移到Person中:
class Person...
   int numberOfAdvancedCourses(Person person) {
      Iterator iter = person.getCourses().iterator();
      int count = 0;
      while(iter.hasNext()) {
         Course each = (Course)iter.next();
         if(each.isAdvanced()) count++;
      }
      return count;
   }
举个常见例子,下列代码:
   kent.getCourses().size();
可以修改更具可读性的样子,像这样:

kent.numberOfCourses();

class Person...
public int numberOfCourses() {
   return _courses.size();
}
数年以前,我曾经担心将这样的行为搬移到Person中会导致Person变得臃肿.但是在实际工作经验中,我发现这通常并不成为问题.

• 加入[为群集添加(add),移除(remove)元素]的函数.
• 将[用以保存群集]的值域初始化为一个空群集.
• 编译.
• 找出[群集设值函数]的所有调用者.你可以修改那个设值函数,让它使用上述新建立的[添加/移除元素]函数;也可以直接修改调用端,改让它们调用上述新建立的[添加/移除元素]函数.
  • ==>两种情况下需要用到[群集设值函数];(1)群集为空时;(2)准备将原有群集替换为另一个群集时.
  • ==>你或许会想运用Rename Method(273)为[群集设值函数]改名,从setXxx()改为initializeXxx()或replaceXxx().
• 编译,测试.
• 找出所有[通过取值函数(getter)获得群集并修改其内容]的函数.逐一修改这些函数,让它们改用[添加/移除](add/remove)函数.每次修改后,编译并测试.
• 修改完上述所有[通过取值函数(getter)获得群集并修改群集内容]的函数后,修改取值函数自身,使它返回该群集的一个只读映件(read-only view).
• ==>在Java 2中,你可以使用Collection.unmodifiableXxx()得到该集群的只读映件.
• ==>在Java 1.1中,你应该返回群集的一份拷贝.
• 编译,测试.
• 找出取值函数(getter)的所有用户,从中找出应该存在于[群集之宿主对象(host object)]内的代码.运用Extract Method(110)和Move Method(142)将这些代码移到宿主对象去.

• 修改现有取值函数(getter)的名字,然后添加一个新取值函数,使其返回一个枚举.找出旧取值函数的所有被使用点,将它们都改为使用新取值函数.
• ==>如果这一步跨度太大,你可以先使用Rename Method(273)修改原取值函数的名称;再建立一个新取值函数用以返回枚举;最后再修改所有调用者,使其调用新取值函数.
• 编译,测试.

• 为public值域提供取值/设值函数(getter/setter).
• 找到这个class以外使用该值域的所有地点.如果客户只是使用该值域,就把引用动作(reference)替换为对取值函数(getter)的调用];如果客户修改了该值值域,就将此一引用点替换为[对设值函数(setter)的调用].
• ==>如果这个值域是个对象,而客户只不过是调用该对象的某个函数,那么不论该函数是否为修改函数(modifier,会改变对象状态),都只能算是使用该值域.只有当客户为该值域赋值时,才能将其替换为设值函数(setter).
• 每次修改之后,编译并测试.
• 将值域的所有用户修改完毕后,把值域声明为private.
• 编译,测试.

• 声明一个常量,令其值为原本的魔法数值.
• 找出这个魔法数的所有引用点.
• 检查是否可以使用这个新声明的常量来替换该魔法数.如果可以,便以一常量替换之.
• 编译.
• 所有魔法数都被替换完毕后,编译并测试.此时整个程序应该运转如常,就像没有做任何修改一样.
• ==>有个不错的测试办法:检查现在的程序是否可以被你轻松地修改常量值(这可能意味某些预期结果将有所改变,以配合这一新值.实际工作中并非总是可以进行这样的测试).如果可行,这就是一个不错的手法.

• 找出[你想去除的指针]的保存值域,检查它的每一个用户,判断是否可以去除该指针.
• ==>不但要检查[直接读取点],也要检查[直接读取点]的调用函数.
• ==>考虑有无可能不通过指针函数取得[被引用对象](referred object).如果有可能,你就可以对取值函数(getter)使用Substitute Algorithm(139).从而让客户在没有指针的情况下也可以使用该取值函数.
• ==>对于使用该值域的所有函数,考虑将[被引用对象](referred object)作为引数(argument)传进去.
• 如果客户使用了取值函数(getter),先运用Self Encapsulate Field(171)将[待除值域]自我封装起来,然后使用Subsitute Algorithm(139)对付取值函数,令它不再使用该(待除)值域.然后编译,测试.
• 如果客户并使用取值函数(getter),那就直接修改[待除值域]的所有被引用点:改以其他途径获得该值域所保存的对象.每次修改后,编译并测试.
• 如果已经没有任何函数使用该(待除)值域,移除所有[对该值域的更新逻辑],然后移除该值域.
• ==>如果有许多地方对此值域赋值,先运用Self Encapsulate Field(171)使这些地点改用同一个设值函数(setter).编译,测试.而后将这个设值函数的本体清空.再编译,再测试.如果这些都可行,就可以将此值域和其设值函数,连同对设值函数的所有调用,全部移除.
• 编译,测试.

1. 如果两者都是reference objects，而其间的关联是[一对多]关系，那么就由[拥有单一reference]的那一方承担[控制者]角色。以本例而言，如果一个客户可拥有多份定单，那么就由Order class(定单)来控制关联性。
2. 如果某个对象是另一个对象的组成（component），那么由后者负责控制关联性。
3. 如果两者都是reference objects，而其间的关联是[多对多]关系，那么随便其中哪个对象来控制关联性，都无所谓。

• 在referred class中增加一个值域,用以保存[反向指针].
• 决定由哪个class(引用端或被引用端)控制关联性(association).
• 在[被控制]建立一个辅助函数,其命名应该清楚指出它的有限用途.
• 如果既有的修改函数(modifier)在[控制端],让它负责更新反向指针.
• 如果既有的修改函数(modifier)在[控制端]

• 修改presentation class，使其成为domain class的Observer[GoF]。
• ==》如果尚未有domain class，就建立一个。
• ==》如果没有[从presentation class到domain class]的关联性（link），就将domain class保存于presentation class的一个值域中。
• 针对GUI class内的domain data，使用Self Encapsulate Field（171）。
• 编译，测试。
• 在事件处理函数（event handler）中加上对设值函数（setter）的调用，以[直接访问方式]更新GUI组件。
• ==》在事件处理函数中放一个设值函数（setter），利用它将GUI组件更新为domain data的当前值。当然这其实没有必要，你只不过是拿它的值设定它自己。但是这样使用setter，便是允许其中的任何动作得以于日后被执行起来，这是这一步骤的意义所在。
• ==》进行这个改变时，对于组件，不要使用取值函数（getter），应该采取[直接取用]方式，因为稍后我们将修改取值函数（getter），使其从domain object（而非GUI组件）取值。设值函数（setter）也将遭受类似修改。
• ==》确保测试代码能够触发新添加的事件处理（event handling）机制。
• 编译，测试。
• 在domain class中定义数据及其相关访问函数（accessors）。
• ==》确保domain class中的设值函数（setter）能够触发Observer模式的通报机制（notify mechanism）。
• ==》对于被观察（被监视）的数据，在domain class中使用[与presentation class所用的相同型别]（通常是字符串）来保存。后续重构中你可以自由改变这个数据型别。
• 修改presentation class中的访问函数（accessors），将它们的操作对象改为domain object（而非GUI组件）。
• 修改observer的update（），使其从相应的domain object中将所需数据拷贝给GUI组件。
• 编译，测试。
  

• 新建一个class表示数组所示信息，并在该class中以一个public值域保存原先的数组。
• 修改数组的所有用户，让它们改用新建的class实体。
• 编译，测试。
• 逐一为数组元素添加取值/设值函数（getters/setters）。根据元素的用途，为这些访问函数命名。修改客户端代码，让它们通过访问函数取用数组内的元素。每次修改后，编译并测试。
• 当所有[对数组的直接访问]都被取代为[对访问函数的调用]后，将class之中保存该数组的值域声明为private。
• 编译。
• 对于数组内的每一个元素，在新class中创建一个型别相当的值域；修改该元素的访问函数，令它改用上述的新建值域。
• 每修改一个元素，编译并测试。
• 数组的所有元素都在对应的class内有了相应值域之后，删除该数组。
  

• 检查重构对象是否为immutable（不可变）对象，或是否可修改为不可变对象。
• ==》如果该对象目前还是immutable，就使用Remove Setting Method（300），直到它成为immutable为止。
• 如果无法将该对象修改为immutable，就放弃使用本项重构。
• 建立equals（）和hashCode（）。
• 编译，测试。
• 考虑是否可以删除factory method，并将构造函数声明为public。