Effective_java之二：慎用重载函数

每周写一篇技术博客的愿望一直没实现， 从这周開始每周五晚10点是写博客的时间

OOP的一个重要特性就是多态，实现多态的目的有多种途径。比方：重载overload、重写overwite、面向接口编程等等。可是在实际应用中应该慎用重载，这也是Effective Java中提到的一条。以下先展示下eJava中提到的代码：

@Test
public void testOverWrite(){
List<Integer> intList = new ArrayList<Integer>();
Set<Integer> intSet = new HashSet<Integer>();

for(int i = -3 ; i < 3 ; i++){
intList.add(i);
intSet.add(i);
}
System.out.println(intList+" ---> "+intSet);

for(int i =0 ; i< 3 ;i++){
intList.remove(i);
intSet.remove(i);
}

System.out.println(intList+" ### "+intSet);

}

假设没有test的话可能非常多人会以为输出这样吧：

[-3, -2, -1, 0, 1, 2]  --->  [0, 1, 2, -3, -2, -1]
[-3, -2, -1] ###  [-3, -2, -1]

可是结果却是这种：

[-3, -2, -1, 0, 1, 2]  --->  [0, 1, 2, -3, -2, -1]
[-2, 0, 2]  ###  [-3, -2, -1]

第一行肯定都没问题，intSet也没问题。intList可能非常多人会有疑问了‘’为什么跟intSet不一样了‘

事实上在JDK5之前也没这问题，jdk5及以后添加了自己主动封装箱的功能，基本类型和对引用类型会自己主动帮你转换。

这样就导致了List在remove的时候移除的是索引，而不是你以为的容器内的数据。

    public E remove(int index) {
        rangeCheck(index);


        modCount++;
        E oldValue = elementData(index);


        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // Let gc do its work


        return oldValue;
    }

而非这个函数：

public boolean remove(Object o) {
        if (o == null) {
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
                    fastRemove(index);
                    return true;
                }
        } else {
            for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {
                    fastRemove(index);
                    return true;
                }
        }
        return false;
    }

jdk自己主动帮你解装箱了。而HashSet没有remove索引的方法所以调用了是remove对象

  public boolean remove(Object o) {
        return map.remove(o)==PRESENT;
    }

因此不会出现list那种问题。

所以当List remove一个Integer对象的时候须要注意，非常可能结果不是你想要的功能。

-------------------------美丽的切割线——————————————————

二、当參数列表类似时，最好不要用重载。特别是导出公共的API。最easy是 使用者 造成困惑。如我今天遇到的一公共Money类中有两个參数列表同样的函数：multiply和multiplyBy,拥有同样的參数列表。首次使用时跟进去细致开了代码，记住了multiply内部是新new了个对象，原来对象的值不变。也理解了这个值是不能改变的。可是这次上线前优化了行代码，使用了’multiply‘.測试时仅仅跟进了上半部分，发现数据是对的。结果最后又问题了，最后发现使用了是multiplyBy，而该函数是改变原来对象的。浪费了一时间。为什么不写全称呢？一个函数名大概最多能够用65535个字符长度，貌似再复杂的业务函数名也用不了这么长吧。

————————华丽的切割线————————————————-———

三、观察代码：

private static void printClassName(Set<?> set){
System.out.println(set.getClass().getSimpleName());
}
private static void printClassName(List<?> list){
System.out.println(list.getClass().getSimpleName());
}
private static void printClassName(Collection<?> col){
System.out.println("unknow class name...");
}
public static void main(String[] args) {
String[] str = {"a","b"};
Collection<Integer>[] cols = {
new HashSet<Integer>(),
new ArrayList<Integer>(),
new HashMap<Integer,Integer>()
};
for(Collection col : cols){
printClassName(col)
}
}

overwiter是在父子类间实现，overload是在同一个类中实现。所以overload是编译期决定的。依据引用的类型决定调用哪个方法。所以上述三次都会打印’unknow class name‘.由于编译器col都是collection类型的。

而overload是依据执行时被调用方法所在类实例的类型选择方法的， 所以会使用子类中被复写的实现。