编写高质量代码：改善java程序的151个建议（1~10）

建议一：不要在常量和变量中出现易混淆的字母

包名全小写，类名首字母大写，常量全部大写且用下划线分割，变量采用驼峰命名法。

字母“l”和“O”必须标注，以示区分。

字母“l”作为长整型标志时必须大写。

建议二：莫让常量蜕变为变量

public class test {
    public static void main(String[] args) {
        long i = 1L;
        System.out.println(Const.RAND_CONST);
    }

    interface Const {
        public static final int RAND_CONST = new Random().nextInt();
    }
}

常量就是常量，不要为常量附上随机数。

建议三：三元操作符的类型务必一致

三元操作符是if-else的简化写法

public class test {
    public static void main(String[] args) {
        int i =80;
        String a = String.valueOf(i<100?90:100);
        String b = String.valueOf(i<100?90:100.0);
        System.out.println("两者是否相同"+a.equals(b));
    }
}

三元操作符会自动转换两个操作符的类型相同，不能强转时返回Object。

建议四：避免带有变长参数的方法重载

public class Client {
    /**
     * 简单折扣计算
     *
     * @param price
     * @param discount
     */
    public void calPrice(int price, int discount) {
        float knockdownPrice = price * discount / 100.0F;
        System.out.println("简单折扣后的价格是： " + formateCurrency(knockdownPrice));
    }

    /**
     * 复杂折扣计算：折上折
     *
     * @param price
     * @param discounts
     */
    public void calPrice(int price, int... discounts) {
        float knockdownPrice = price * 2;
        for (int discount : discounts) {
            knockdownPrice = knockdownPrice * discount / 100;
        }
        System.out.println("复杂折扣运算后的价格是: " + formateCurrency(knockdownPrice));
    }

    /**
     * 格式化成本的货币形式
     *
     * @param price
     * @return
     */
    private String formateCurrency(float price) {
        return NumberFormat.getCurrencyInstance().format(price / 100);
    }

    public static void main(String[] args) {
        Client client = new Client();
        client.calPrice(49900, 75);
    }
}

当传入的参数为（49900,75）时，调用了第一个方法，而不是第二个方法，重载变长参数时，会使编译器无法判断应调用哪个方法，只能根据默认的调用。

建议五：别让null值和空值威胁到变长方法

public class Client {
    public void methodA(String str, Integer... is){};
    public void methodA(String str, String... strs){};

    public static void main(String[] args) {
        Client client = new Client();
        client.methodA("China", 0);
        client.methodA("China","people");
        client.methodA("China");
        client.methodA("China", null);
    }
}

client.methodA("China");
client.methodA("China", null);

这两个方法会报错，编辑器不知道调用哪个方法。应当给null和空值定义一个类型。

不能直接定义空值，只能定义String或Integer为null。

建议六：覆写变长方法也要循规蹈矩

public class Client {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        // 向上转型
        Base base = new Sub();
        base.print("hello");

        // 不转型
        Sub sub = new Sub();
        sub.print("hello");
    }

}

// 基类
class Base {
    void print(String... args) {
        System.out.println("Base......test");
    }
}

// 子类，覆写父类方法
class Sub extends Base {
    @Override
    void print(String[] args) {
        System.out.println("Sub......test");
    }
}

编译不通过：第一个方法通过，第二个方法不通过。

原因：第一个方法向上转型，形参由父类决定，第二个方法子类直接调用时参数列表不匹配也不会到父类中找，所以出错。

建议七：警惕自增的陷阱

public class Client {
    public static void main(String[] args) {
        int count = 0;
        for (int i = 0; i < 10; i++) {
            count = count++;
        }
        System.out.println("count = " + count);
    }
}

结果：count = 0

注意count++，count = count++，count= ++count的区别

建议八：不要让旧语法困扰你

public class Client {
    public static void main(String[] args) {
        int fee = 100;
        saveDefault:save(fee);
    }
    static void saveDefault(){};
    static void save(int fee){};
}

java抛弃了goto语法，但仍保留着该关键字以及const关键字，只是不做处理而已。旧语法尽量少用。

建议九：少用静态导入

public class Client {
    /**
     * 计算圆面积，不使用静态导入
     *
     * @param r
     * @return
     */
    public static double calCircleArea(double r) {
        return PI * r * r;
    }

    /**
     * 计算求面积，使用静态导入
     *
     * @param r
     * @return
     */
    public static double calBallArea(double r) {
        return 4 * PI * r * r;
    }
}

静态导入的作用是将Math类中的PI常量引入到本类中，使程序更加简单。但滥用静态导入会使程序不容易读，不知道该方法来自于那个类。

建议十：不要在本类中覆盖静态导入的变量和方法

public class Client {
//    常量名与静态导入的PI相同
    public final static String PI = "祖冲之";

//    方法名与静态导入的相同
    public static int abs(int abs) {
        return 0;
    }

    public static void main(String[] args) {
        System.out.println("PI = "+PI);
        System.out.println("abs(100) = " +abs(100));
    }
}

容易搞混该方法是否是属于那个类的。