Large Class--过大的类--要重构的信号
如果想利用单个类做太多事情，其内往往就会出现太多实例变量。一旦如此，Duplicated Code也就接踵而至。
解决方法：
1.将类内彼此相关的变量，将它们放在一起。使用Extract Class手法，将彼此相关的变量提炼到新的类。
2.如果1中的新类适合作为一个子类，那么可以使用Extract Subclass手法。
11.对于太多代码的处理办法，分解函数，将大函数分解成若干小函数，这样可以消除重复代码。相关的函数，可以跟着变量，一起被提炼到一个新的类中去，使用Extract Class手法或者Extract Subclass。
12.实现11时，要确定客户端如何使用提炼的类，然后，使用Extract Interface手法，为每种使用方式提炼出一个接口。
111.如果当前过大的类是GUI类，那么，新提炼的类和当前类，两边要各保留一些重复数据，并保持同步。这要使用Duplicate Observed Data手法。
具体处理手法介绍：
1. Extract Subclass
类中的某些特性只被某些(而非全部)实例用到。
出现这种特征，可以创建一个子类，该子类只使用这部分特性。这样，就把子类专有的特性从原来的类中
提炼出来，从而让原来的类变得不那么大。
重点是要识别出这种情况的存在，比如：Job Item有一种使用情况，只是使用getUnitPrice,getEmployee，
不使用Job Item的其它特性。那么，就可以把使用getUnitPrice,getEmployee提炼为一个类，在这里使用
Extract Subclass手法。
再比如：
1: public class Registration
2: {
3: public NonRegistrationAction Action { get; set; }
4: public decimal RegistrationTotal { get; set; }
5: public string Notes { get; set; }
6: public string Description { get; set; }
7: public DateTime RegistrationDate { get; set; }
8: }
这个类，有两个使用场景，一个是注册的；一个是非注册的。作为注册实例的时候，它只使用到RegistrationDate,Description,RegistrationTotal方法，没有使用其它方法；
而作为非注册实例来使用的时候，只是使用NonRegistrationAction,Notes方法。
符合特征，类中的某些特性只被某些(而非全部)实例用到。这里如果使用Extract Subclass手法， 那么，
处理后，结果是这样：
1: public class Registration
2: {
3: public decimal RegistrationTotal { get; set; }
4: public string Description { get; set; }
5: public DateTime RegistrationDate { get; set; }
6: }
7:
8: public class NonRegistration : Registration
9: {
10: public NonRegistrationAction Action { get; set; }
11: public string Notes { get; set; }
12: }
2.Extract Interface
“使用一个类”的含义解读，下述情况之一:
1).使用该类的所有责任区。
2).某一组客户只使用类责任区中的一个特定子集。
3).该类需要与所有协助处理某些特定请求的类协作。
对于2),3)的情况，将一个类中的这部分责任分离出来，这样有意义。因为，
这样可以更容易看清楚类的责任划分。
所以，Extract Interface手法做的事情，就是把原来类中的部分子集，部分责任分离出来。
例子：
Employee类，提供了很多功能，但是，有部分类，只使用它的getRate()和hasSpecialSkill()功能。
那么，为了让Employee类变小，可以把它的这两个功能，getRate()和hasSpecialSkill()提炼出来。提炼为接口
interface Billable{
public int getRate();
public boolean hasSpecialSkill();
}
然后Employee类实现接口Billable。
这样，那些只需要使用到Employee类getRate()，hasSpecialSkill()功能的类，只需要使用接口Billable就可以，这样，只是暴露了Billable功能给使用者。也就是，只给使用者提供它们可以使用的功能，其它功能子集无需提供。
多个使用者，只关注getRate()，hasSpecialSkill()功能，不同的使用者，会要求不同的实现。这时，就可以进行不同的实现来满足使用者的要求。
3.Duplicate Observed Data(复制“被监视的数据”)
场景：
一个GUI类，包含了业务处理代码和用户界面代码。当业务逻辑的增加， 会让这个类越来越大，而且逻辑会复杂。这是因为，一个GUI类同时承担了两种责任，业务处理功能和界面渲染功能。这时候，就需要把业务处理代码从GUI类中分离出来。
业务处理代码和界面显示代码分离开之后，方便维护和方便开发。在进行业务处理时，需要使用到界面数据，而界面进行更新的时候，也会需要使用到业务处理的结果。这时，就需要数据在业务层和界面层之间进行同步。
而这个手法，可以实现上述同能，业务层(领域层)和界面层的数据同步。
例子：
下面的内容都是IntervalWindow类：
public class IntervalWindow extends Frame...
java.awt.TextField _startField;
java.awt.TextField _endField;
java.awt.TextField _lengthField;
class SymFocus extends java.awt.event.FocusAdapter
{
public void focusLost(java.awt.event.FocusEvent event)
{
Object object = event.getSource();
if (object == _startField)
StartField_FocusLost(event);
else if (object == _endField)
EndField_FocusLost(event);
else if (object == _lengthField)
LengthField_FocusLost(event);
}
}
一个GUI界面，有三个文本框，当某个文本框输入内容，离开时，也就是失去焦点的时候，会触发一个计算。
Start文本框失去焦点的时候，执行StartField_FocustLost方法；
End文本框失去焦点的时候，执行EndField_FocusLost方法；
Length文本框失去焦点的时候，执行LengthField_FocusLost方法。
Start文本框和End文本框，失去焦点时，做的事情是，检查文本框的输入是否是整数，如果不是，则将文本框的内容设置为0；然后，计算Length文本框的内容。
Length文本框失去焦点的时候，做的事情是，检查文本框的输入是否是整数，如果不是，则将文本框的内容设置为0；然后，计算当前文本框的值。
这是界面操作代码。
void StartField_FocusLost(java.awt.event.FocusEvent event) {
if (isNotInteger(_startField.getText()))
_startField.setText("0");
calculateLength();
}
void EndField_FocusLost(java.awt.event.FocusEvent event) {
if (isNotInteger(_endField.getText()))
_endField.setText("0");
calculateLength();
}
void LengthField_FocusLost(java.awt.event.FocusEvent event) {
if (isNotInteger(_lengthField.getText()))
_lengthField.setText("0");
calculateEnd();
}
void calculateLength(){
try {
int start = Integer.parseInt(_startField.getText());
int end = Integer.parseInt(_endField.getText());
int length = end - start;
_lengthField.setText(String.valueOf(length));
} catch (NumberFormatException e) {
throw new RuntimeException ("Unexpected Number Format Error");
}
}
void calculateEnd() {
try {
int start = Integer.parseInt(_startField.getText());
int length = Integer.parseInt(_lengthField.getText());
int end = start + length;
_endField.setText(String.valueOf(end));
} catch (NumberFormatException e) {
throw new RuntimeException ("Unexpected Number Format Error");
}
}
calculateLength()方法和calculateEnd()方法，它包含了计算的逻辑，还包含了对界面组件的引用。我们现在想做的事情，就是，让这两个方法与界面组件(_startField,_endField,_lengthField)解耦。
这里就可以使用到Duplicate Observed Data手法。创建一个领域类，领域类和界面类的数据同步；领域类的数据发生更新后，会将结果传递给界面类。
-------------------------------------------------------------------------------------------------------
应用Duplicate Observed Data手法之后，得到如下代码：
整个流程就变成这样：
1.GUI类，IntervalWindow初始化时，使用的是Interval这个类的值。
2.当GUI类发生事件变化的时候，把组件的值传递给_subject实例，并进行计算。
3._subject计算完毕，再通知GUI类界面进行更新。
在这里，计算的逻辑，被分割到_subject实例(领域类)。
数据的传递流程：
领域类，界面初始值数据------>{界面生成(GUI类)------>领域类------>界面}------>{界面生成(GUI类)--->领域类--->界面}
public class IntervalWindow extends Frame implements Observer{
private Interval _subject;
public IntervalWindow(){
_subject = new Interval();
_subject.addObserver(this);
update(_subject, null);
}
String getEnd() {
return _subject.getEnd();
}
void setEnd (String arg) {
_subject.setEnd(arg);
}
void StartField_FocusLost(java.awt.event.FocusEvent event) {
if (isNotInteger(_startField.getText()))
_startField.setText("0");
_subject.setStart(_startField.getText());
_subject.calculateLength();
}
void EndField_FocusLost(java.awt.event.FocusEvent event) {
if (isNotInteger(_endField.getText()))
_endField.setText("0");
_subject.setEnd (_endField.getText());
_subject.calculateLength();
}
void LengthField_FocusLost(java.awt.event.FocusEvent event) {
if (isNotInteger(_lengthField.getText()))
_lengthField.setText("0");
_subject.setLength(_lengthField.getText());
_subject.calculateEnd();
}
@Override
public void update(Observable observed, Object arg) {
_endField.setText(_subject.getEnd());
_startField.setText(_subject.getStart());
_lengthField.setText(_subject.getLength());
}
}
-------------------------------
class Interval extends Observable {
private String _end = "0";
private String _start = "0";
private String _length ="0";
String getEnd() {
return _end;
}
void setEnd (String arg) {
_end = arg;
setChanged();
notifyObservers();
}
String getStart(){
return _start;
}
void setStart(String arg){
_start = arg;
setChanged();
notifyObservers();
}
String getLength(){
return _length;
}
void setLength(String arg){
_length = arg;
setChanged();
notifyObservers();
}
void calculateLength(){
try {
int start = Integer.parseInt(getStart());
int end = Integer.parseInt(getEnd());
int length = end - start;
setLength(String.valueOf(length));
} catch (NumberFormatException e) {
throw new RuntimeException ("Unexpected Number Format Error");
}
}
void calculateEnd() {
try {
int start = Integer.parseInt(getStart());
int length = Integer.parseInt(getLength());
int end = start + length;
setEnd(String.valueOf(end));
} catch (NumberFormatException e) {
throw new RuntimeException ("Unexpected Number Format Error");
}
}
}
参考资料：
https://sourcemaking.com/refactoring/duplicate-observed-data
https://lostechies.com/seanchambers/2009/08/20/refactoring-day-20-extract-subclass/
http://www.refactoring.com/catalog/duplicateObservedData.html
http://www.refactoring.com/catalog/extractSubclass.html