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，其二、我
的程序里没有设计模式。（我才知道，编程原来是为了测试和设计模式，而不是为了原来的需求），今天，仅
以此文献给钟爱于那些流行编码风格的程序员们。
