2017-02-13 00:00:00 +0000   |     java effective java code style   |   Viewed times   |    

方法名风格保持一致

这没什么好说的,方法名用首字母小写的驼峰形式:methodName()。用词注意。

方法参数不要太多

实在参数太多的情况下,可以有三个解决办法,

使用静态成员辅助类。将多个参数定义成一个结构体。

比如下面这种情况,

public void playCards(String cardName, int cardColor) {
    // ... ...
}

就可以设计一个Card类型。

class Card {
    private final String name;
    private final int color;
}

然后用Card型做参数,

public void playCards(Card card) {
    // ... ...
}

用Builder模式

更加复杂的情况可以定义一个Builder模式的辅助类。允许客户端程序员一个一个地设参数。

设计功能正交的子方法

比如,查找子列表sublist中的首元素这个方法,需要三个参数,

//查找子列表sublist中的首元素这个方法
public int firstInSublist(int fromIndex, int toIndex, E element) {
    // ... ...
}

可以设计成两个正交的子方法来完成同样的任务,先获取子列表,

// 先返回子列表
public List<E> sublist(int fromIndex, int toIndex) {
    // ... ...
}

然后再查找,

// 先返回子列表
public int firstIndexOf(E element) {
    // ... ...
}

参数类型优先使用接口,而不是类

好处是客户端程序员用起来更舒服。如果某方法虽然只用到Map接口定义的方法,但参数只接受HashMap而不是所有Map,用户就必须将他的TreeMap转成HashMap再用。

慎用重载

就算能用重载,也尽量不要用。使用前也要考虑清楚参数。

因为,对 重载方法(Overloaded method) 的选择是 静态的。换句话说,是编译期做出的决定。没有说好的多态,没有后期绑定。

对于被 覆盖(Override method) 的选择才是动态的。

看下面这个例子,对于下面三个重载方法,我们期望的是能有类似多态的属性。

public static String classify(Set<?> set) { return "Set"; }
public static String classify(List<?> list) { return "List"; }
public static String classify(Collection<?> collection) { return "Collection"; }

但实际上,下面测试,返回的都是Collection。全都调用了第三个重载方法。

    Collection<String> c1 = new HashSet<>();
    Collection<String> c2 = new ArrayList<>();
    Collection<Integer> c3 = new HashMap<String,Integer>().values();
    System.out.println(classify(c1)); // print: Collection
    System.out.println(classify(c2)); // print: Collection
    System.out.println(classify(c3)); // print: Collection

保守方案:所有重载方法,参数数量必须不同

有一个参数和两个参数的两个重载方法,编译器永远不会选错。

大胆方案:就算参数个数相同,必须是“不相关(radically different)”类

“不相关类”是指:两个类都不是对方的子类

小心自动装箱类

因为有了自动装箱功能,int基本型就和Object不是不相关类了。因为int会被自动包装成Integer类。这会导致意想不到的错误,比如,List有两个重载的remove方法,分别为,

下面在list里插入[-3,-2,-1,0,1,2],然后删除[0,1,2]。应该还剩[-3,-2,-1]。但结果返回的却是[-2,-,2]

/**
 * 先插入: -3,-2,-1,0,1,2
 * 再删除: 0,1,2
 * 应该剩下: -3,-2,-1
 * 但输出结果是: -2,0,-2
 * 因为List#remove(Object o)和List#remove(int i)两个版本
 * 这里调用的是List#remove(int i)。先删除第0个位置元素,然后删除第1,2位置的元素。
 * 所以返回-2,0,2
 */
public static void listRemoveError() {
    List<Integer> list = new ArrayList<>();
    for (int i = -3; i < 3; i++) {
        list.add(i);
    }
    for (int i = 0; i < 3; i++) {
        list.remove(i);
    }
    System.out.println(list);
}

慎用可变长参数

基本型数组赋给可变长参数时,会出bug。

可变长参数长度为0时需要强制检查

下面这个函数计算多个int型参数的最小值。问题是总是要检查参数长度就很麻烦,也不美观。

static int min(int... args) {
    if (args.length == 0) {
        throw new IllegalArgumentException("Too few arguments!");
    }
    int min = args[0];
    for (int i = 1; i < args.length; i++) {
        if (args[i] < min) {
            min = args[i];
        }
    }
    return min;
}

解决方案是,使用两个参数,先传单个的int进去,然后再是可变长参数。代码就好多了。

static int min(int first, int... args) {
    int min = first;
    for (int arg : args) {
        if (args[i] < min) {
            min = args[i];
        }
    }
    return min;
}

小心基本型数组

<T> List<T> Arrays.asList(T... args)方法接受接受可变长参数。但因为它是一个泛型方法,编译器在进行类型推断的时候就容易出错。而且更不好的是,它对基本型非常不友好。

@SafeVarargs
public static <T> List<T> asList(T... a) {
    return new ArrayList<>(a);
}

如果我们用Integer作为它的参数,一切正常。因为泛型类型参数T被正确识别为Integer

/**
 * 如果参数是Integer包装类对象的数组,asList()就会把每个Integer对象都插入List。
 */
public static void printArrayWithAsListV3() {
    System.out.println(Arrays.asList(new Integer[]{1,2,3,4,5,6,7,8,9,0}));
}

当我们传递基本型数组int[]进去的时候,不能正常工作。因为编译器把整个数组int[]当成了泛型的类型参数T

/**
 * asList()方法的参数是可变长参数,int[]会被认为是单个数组对象。
 * 所以最终调用的是数组继承自Object的toString()方法,只打印内存地址。
 * public static <T> List<T> asList(T... a) {
 *     return new ArrayList<>(a);
 * }
 */
public static void printArrayWithAsListV2() {
    System.out.println(Arrays.asList(new int[]{1,2,3,4,5,6,7,8,9,0}));
}

可变长参数每次都要初始化数组,开销大

如果对性能要求非常苛刻,可以多写几个重载方法,替代可变长参数。比如下面这个例子,只有当参数长度超过3个的时候,才调用有可变长参数的版本。

foo() {}
foo(int a1) {}
foo(int a1, int a2) {}
foo(int a1, int a2, int a3) {}
foo(int a1, int a2, int a3, int... args) {}