OOP过度抽象

OI的时候，解决问题是第一位的，别老想着可维护性。能过就行啦，又不是工程。

下面是两篇相关的文章

---

来自酷壳 编程真难啊

2009年9月3日 陈皓

上周，在Sun的Java论坛上出现了一个这样的帖子，LZ的贴子翻译如下：

大家好，我是一个Java的新手，我有一个简单的问题：请问我怎么才能反转一个整数的符号啊。比
如把-12转成+12。是的，毫无疑问这是个简单的问题，但我弄了一整天我也找不到什么好的方法。
非常感谢如果你能告诉我Java有什么方法可以做到这个事，或者告诉我一个正确的方向——比如使
用一些数学库或是二进制方法什么的。谢谢！

这个贴子的沙发给出了答案：

n = -n;

然后:

public interface Negatable<T extends Number> {
  T value();
  T negate();
}
public abstract class NegatableInteger implements Negatable<Integer> {
  private final int value;
  protected NegatableInteger(int value) {
    this.value = value;
  }
  public static NegatableInteger createNegatableInteger(int value) {
    if (value > 0) {
      return new NegatablePositiveInteger(value);
    }
    else if (value == Integer.MIN_VALUE) {
      throw new IllegalArgumentException("cannot negate " + value);
    }
    else if (value < 0) {
      return new NegatableNegativeInteger(value);
    }
    else {
      return new NegatableZeroInteger(value);
    }
  }
  public Integer value() {
    return value;
  }
  public Integer negate() {
    String negatedString = negateValueAsString ();
    Integer negatedInteger = Integer.parseInt(negatedString);
    return negatedInteger;
  }
  protected abstract String negateValueAsString ();
}
public class NegatablePositiveInteger extends NegatableInteger {
  public NegatablePositiveInteger(int value) {
    super(value);
  }
  protected String negateValueAsString () {
    String valueAsString = String.valueOf (value());
    return "‐" + valueAsString;
  }
}
public class NegatableNegativeInteger extends NegatableInteger {
  public NegatableNegativeInteger (int value) {
    super(value);
  }
  protected String negateValueAsString () {
    String valueAsString = String.valueOf (value());
    return valueAsString.substring(1);
  }
}
public class NegatableZeroInteger extends NegatableInteger {
  public NegatableZeroInteger (int value) {
    super(value);
  }
  protected String negateValueAsString () {
    return String.valueOf (value());
  }
}

有人说，要用try catch；有人说要使用XML配置文件……，程序员们在追逐更为变态和疯狂的东西，并从中找
到快乐，呵呵。

来自酷壳 代码重构的一个示例

首先，我们有一个表达式如下所示：

s = 7;

很明显，这个表达式的变量名太没意义了，很不利于程序的可读性，所以，我们需要取一个有意义的变量名：

slots = 7;

很好，不过，那个常量7是hard-code或是一个Magic number，而且，这常量没有名字也不利于代码的可读性

啊。再改：

SEVEN = 7;
...
slots = SEVEN;

靠！上面，是这是哪门子的改法？（不过，我保证这是真实发生的），常量名也要有意义一点嘛，再改：

SLOTS_PER_WIDGET = 7;
...
slots = SLOTS_PER_WIDGET;

这还差不多，不过，名字可能会重名啊，最好放到一个类中：

import widgetConstants;
...
slots = widgetConstants.SLOTS_PER_WIDGET;

现在看起来好很多了，不过，即然面向对象了，我们当然要学会使用Design Pattern，比如Factor啊，或是Singleton啊什么的：

widgetModelFactory = WidgetModelFactory.getInstance();
widgetModel = widgetModelFactory.getWidgetModel() ;
slots = widgetModel.getSlotsPerWidget();

当然，要是考虑到整体的类结构，上面的那些还不够，下面是我们最终的重构代码：（欢迎来到真实的Java世
界）

context = Context.getCurrentContext();
serviceDirectoryFactory = ServiceDirectoryFactory.getServiceDirectory(context);
serviceDirectory = serviceDirectoryFactory.getServiceDirectory(context);
serviceDescriptor = ServiceDescriptorFactory.getDescriptor("widgetModelFactory");
widgetModelFactoryServiceLocator = serviceDirectory.getServiceLocator(serviceDescriptor,context);
widgetModelFactory = (WidgetModelFactory)widgetModelFactoryServiceLocator.findService(context);
widgetModel = widgetModelFactory.getWidgetModel(context);
slots = widgetModel.getSlotsPerWidget();

这就是我们的面向对象的编程模式，记得N年前在面试那家著名的以鼓吹敏捷方法论的公司时，在用程序实现
一个程序题的时候，他们对我的程序很不屑一顾，原因有两个，其一、我没有使用TDD写UT Case，其二、我
的程序里没有设计模式。（我才知道，编程原来是为了测试和设计模式，而不是为了原来的需求），今天，仅
以此文献给钟爱于那些流行编码风格的程序员们。