Java开发中通用的方法和准则20条

1. 不要在常量和变量中出现易混淆的字母

包名全小写、类名首字母全大写、常量全部大写并下划线分割、变量采用驼峰命名等，这些是最基本的Java编码规范。

public class TestDemo {
      public static void main(String[] args) {
            long i = 1l;
            System.out.println("i的两倍是：" + (i+i)); //2
      }
}

字母 "l" 作为长整型标志时，务必大写！

2. 不要让常量变成变量

public class TestDemo {
      public static void main(String[] args) {
            System.out.println("这次常量值是：" + Const.RAND_CONST); //  每次运行值不一样
      }
}
interface Const {
      public static final int RAND_CONST = new Random().nextInt();
}

务必让常量的值在运行期保持不变。

3. 三元操作符的类型必须一致

public class TestDemo {
      public static void main(String[] args) {
            int i = 80;
            String s1 = String.valueOf(i < 100 ? 90 : 100);
            String s2 = String.valueOf(i < 100 ? 90 : 100.0);
            System.out.println(s1 + " " + s2); // 90 90.0
            System.out.println("两者是否相等：" + s1.equals(s2)); //  false
      }
}

保证三元操作符中的两个操作数类型一致，即可减少诸多可能错误的发生。

4. 避免带有变长参数的方法重载

public class TestDemo {
      public static void main(String[] args) {
            Client client = new Client();
            // 499元的货物，75折 == 374.25
            client.calPrice(49900, 75); // 简单折扣的价格：374.25
      }
}
class Client{
      public void calPrice(int price, int discount) {
            float knockdownPrice = price * discount / 100.0F;
            System.out.println("简单折扣的价格：" +  formateCurrency(knockdownPrice));
      }
      public void calPrice(int price, int... discounts) {
            float knockdownPrice = price;
            for (int i : discounts) {
                  knockdownPrice = knockdownPrice * i / 100;
            }
            System.out.println("复杂折扣的价格：" +  formateCurrency(knockdownPrice));
      }
      // 格式化货币形式
      private String formateCurrency(float price) {
            return  NumberFormat.getCurrencyInstance().format(price/100);
      }
}

避免带有变长参数的方法重载，以免陷入某些伤脑筋的小陷阱里。

5. 别让 null 值和空值威胁到变长方法

public class TestDemo {
      public static void main(String[] args) {
            TestDemo t = new TestDemo();
            
            String[] ss = null;
            t.m1("china", ss); // 此处可以编译过
            t.m1("aaa", 0);
            t.m1("china", "people");
            t.m1("china", null); // 此处编译不过，为何？
      }
      
      public void m1(String s, Integer... is) {
            System.out.println("111");
      }
      
      public void m1(String s, String... strs) {
            System.out.println("222");
      }
}

null值对于可变长参数来说，需要确保让编译器知道其类型，否则会有编译报错。

6. 重写变长方法也循规蹈矩

public class TestDemo {
      public static void main(String[] args) {
            Base b = new Sub();
            b.fun(100, 50);
            Sub sub = new Sub();
            sub.fun(100, 50); // 报错！！！
      }
}
class Base {
      void fun(int p, int... d) {
      }
}
class Sub extends Base {
      void fun(int p, int[] d) {
            
      }
}

重写的方法参数与父类相同，不仅仅是类型、数量，还需要包括显示形式。

7. 警惕自增的陷阱

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

后++的操作，赋值时，会先取值，后运算++。因此避免同时++时赋值的操作。

8. 不要让旧语法困扰你

public class TestDemo {
      public static void main(String[] args) {
            int f = 200;
            saveDefault:save(f); // 编译不报错，输出 200
      }
      static void saveDefault() { }
      static void save(int fee) {
            System.out.println(fee);
      }
}

可读性优先，旧的语法纵然不报错，也得让它随风去吧...

未完待续...