目录
频道首页
编写高质量代码:改善Java程序的151个建议 | 第一章 Java开发中通用的方法和准则
收藏
2
Rocky-BCRJ 最近修改于 2023-05-14 23:25:22

编写高质量Java代码的151个建议

圈主 [Rocky编程日记] 学习编写高质量Java代码的151个建议记录。
希望我写得笔记你能够喜欢, 希望我写的笔记能够给你提供帮助。
​
同时若笔记中存在不对的地方,那一定是圈主当时的理解还不够, 希望你能够及时指出嗷~
​
前人述备矣, 我只是知识的搬运工~
​
代码仓库地址:
​
code-improve-suggest

第一章 Java开发中通用的方法和准则

建议1:不要在常量和变量中出现易混淆的字母
  • i、l、1混用;o、0混用等

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

    此情此景就有可能会出现。所以,为了让您的程序更容易理解,字母“I”(还包括大写字母“O")尽量不要和数字混用,以免使阅读者的理解与程序意图产生偏差。如果字母和数字必须混合使用,字母“1”务必大写,字母“O”则增加注释。

建议2:莫让常量蜕变成变量
  • 代码在运行过程中不要去改变常量值

    public class Suggest2 {
    ​
        public static void main(String[] args) {
            System.out.println("常量会变噢: " + Const.RAND_CONST);
        }
    }
    ​
    public interface Const {
    ​
        public static final int RAND_CONST = new Random().nextInt();
    ​
    }
    

    这种常量的定义方式是极不可取的,常量就是常量,在编译期就必须确定其值,不应该在运行期更改,否则程序的可读性会非常差,甚至连作者自己都不能确定在运行期发生了何种神奇的事情。

建议3:三元操作符的类型务必一致
  • 不一致会导致自动类型转换,类型提升int->float->double等。需要保证三元操作符的两个操作数类型一致, 即可减少可能错误的发生。

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

    三元操作符是 if - else 的简化写法, 在项目中使用它的地方很多, 但是好用又简单的东西并不表示就可以随便用。

    三元操作符类型的转换规则:

    • 若两个操作数不可转换,则不做转换,返回值为Object类型。

    • 若两个操作数是明确类型的表达式(比如变量),则按照正常的二进制数字来转换,int类型转换为long类型,long 类型转换为float类型等。

    • 若两个操作数中有一个是数字S,另外一个是表达式,且其类型标示为T,那么,若数字S在T的范围内,则转换为T类型﹔若S超出了T类型的范围,则T转换为S类型(可以参考“建议22”,会对该问题进行展开描述)。

    • 若两个操作数不可转换,则不做转换,返回值为Object类型。 若两个操作数是明确类型的表达式(比如变量),则按照正常的二进制数字来转换,int类型转换为long类型,long 类型转换为float类型等。

    • 若两个操作数中有一个是数字S,另外一个是表达式,且其类型标示为T,那么,若数字S在T的范围内,则转换为T类型﹔若S超出了T类型的范围,则T转换为S类型(可以参考“建议22”,会对该问题进行展开描述)。 若两个操作数都是直接量数字(Literal) 9,则返回值类型为范围较大者。 保证三元操作符中的两个操作数类型一致,即可减少可能错误的发生。

建议4:避免带有变长参数的方法重载
  • 变长参数的方法重载之后可能会包含原方法

    public class Suggest4 {
    ​
     &nbsp; &nbsp;// 简单折扣计算
     &nbsp; &nbsp;public void calPrice(int price, int discount) {
     &nbsp; &nbsp; &nbsp; &nbsp;float knockdownPrice = price * discount / 100.0F;
     &nbsp; &nbsp; &nbsp; &nbsp;System.out.println("简单折扣后的价格是: " + formatCurrency(knockdownPrice));
     &nbsp;  }
     &nbsp; &nbsp;// 复杂多折扣计算
     &nbsp; &nbsp;public void calPrice(int price, int... discounts) {
     &nbsp; &nbsp; &nbsp; &nbsp;float knockdownPrice = price;
     &nbsp; &nbsp; &nbsp; &nbsp;for (int discount : discounts) {
     &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;knockdownPrice = price * discount / 100;
     &nbsp; &nbsp; &nbsp;  }
     &nbsp; &nbsp; &nbsp; &nbsp;System.out.println("复杂折扣后的价格是: " + formatCurrency(knockdownPrice));
     &nbsp;  }
    ​
     &nbsp; &nbsp;private String formatCurrency(float price) {
     &nbsp; &nbsp; &nbsp; &nbsp;return NumberFormat.getCurrencyInstance().format(price / 100);
     &nbsp;  }
    ​
     &nbsp; &nbsp;public static void main(String[] args) {
     &nbsp; &nbsp; &nbsp; &nbsp;Suggest4 suggest4 = new Suggest4();
     &nbsp; &nbsp; &nbsp; &nbsp;suggest4.calPrice(49900, 75);
     &nbsp;  }
    }
    ​
    

    Java 5引入变长参数( varags)就是为了更好垃提高方法的复用性,让方法的调用者可以“随心所欲”地传递实参数量,当然变长参数也是要遵循一定规则的,

    比如变长参数必须是方法中的最后一个参数: 一个方法不能定义多个型长参数等,这些基本规则需要牢记,但是即使记住了这些规则,仍然有可能出现错误。

    因为Java在编译时,首先会根据实参的数量和类型(这里是2个实参,都为int类型,注意没有转成int数组〉来进行处理,也就是查找到calPrice(int price,int discount)方法,而且确认它是否符合方法签名条件。

    现在的问题是编译器为什么会首先根据2个int类型的实参而不是1个int类型、1个int数组类型的实参来查找方法呢﹖这是个好问题,也非常好回答:

    因为int是一个原生数据类型,而数组本身是一个对象,编译器想要“偷懒”,于是它会从最简单的开始“猜想”,只要符合编译条件的即可通过,于是就出现了此问题。

建议5:别让null值和空值威胁到变长方法
  • 两个都包含变长参数的重载方法,当变长参数部分空值,或者为null值时,重载方法不清楚会调用哪一个方法

    public class Suggest5 {
    ​
     &nbsp; &nbsp;public void methodA(String str, Integer... is){
     &nbsp; &nbsp; &nbsp; &nbsp;
     &nbsp;  }
    ​
     &nbsp; &nbsp;public void methodA(String str, String... strs){
    ​
     &nbsp;  }
     &nbsp; &nbsp;
     &nbsp; &nbsp;public static void main(String[] args) {
     &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;Suggest5 suggest5 = new Suggest5();
     &nbsp; &nbsp; &nbsp; &nbsp;suggest5.methodA("Rocky编程日记",0);
     &nbsp; &nbsp; &nbsp; &nbsp;suggest5.methodA("Rocky编程日记","Rocky");
     &nbsp; &nbsp; &nbsp; &nbsp;// suggest5.methodA("Rocky编程日记");
     &nbsp; &nbsp; &nbsp; &nbsp;// suggest5.methodA("Rocky编程日记",null);
     &nbsp;  }
    }
    

    有两处编译通不过:

    client.Method A(“中国”)和client.Method A(中国,null),估计你已经猜到了,两处的提示是相同的:方法模糊不清,编译器不知道调用哪一个方法,但这两处代码反映的代码味道可是不同的。

    第一个不符合懒人原则外,第二个是调用者隐藏了实参类型,这是非常危险的,不仅仅调用者需要“猜测”该调用哪个方法,而且被调用者也可能产生内部逻辑混乱的情况。对于本例来说应该做如下修改:

    public static void main(String[] args) {
     &nbsp; &nbsp; &nbsp; &nbsp;Suggest5 suggest5 = new Suggest5();
     &nbsp; &nbsp; &nbsp; &nbsp;suggest5.methodA("Rocky编程日记",0);
     &nbsp; &nbsp; &nbsp; &nbsp;suggest5.methodA("Rocky编程日记","Rocky");
     &nbsp; &nbsp; &nbsp; &nbsp;// suggest5.methodA("Rocky编程日记");
     &nbsp; &nbsp; &nbsp; &nbsp;// suggest5.methodA("Rocky编程日记",null);
     &nbsp; &nbsp; &nbsp; &nbsp;String[] s = null;
     &nbsp; &nbsp; &nbsp; &nbsp;suggest5.methodA("Rocky编程日记", s);
     &nbsp;  }
    
建议6:覆写变长方法也循规蹈矩
  • 变长参数与数组,覆写的方法参数与父类相同,不仅仅是类型、数量,还包括显示形式

    public class Suggest6 {
    ​
     &nbsp; &nbsp;public static void main(String[] args) {
     &nbsp; &nbsp; &nbsp; &nbsp;// 向上转型
     &nbsp; &nbsp; &nbsp; &nbsp;Base base = new Sub();
     &nbsp; &nbsp; &nbsp; &nbsp;base.fun(100, 50);
     &nbsp; &nbsp; &nbsp; &nbsp;// 不转型
     &nbsp; &nbsp; &nbsp; &nbsp;Sub sub = new Sub();
    // &nbsp; &nbsp; &nbsp;  sub.fun(100, 50);
     &nbsp;  }
     &nbsp; &nbsp;// 基类
     &nbsp; &nbsp;static class Base {
     &nbsp; &nbsp; &nbsp; &nbsp;void fun(int price, int... discounts) {
     &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;System.out.println("Base.....fun");
     &nbsp; &nbsp; &nbsp;  }
     &nbsp;  }
     &nbsp; &nbsp;// 子类, 覆写父类方法
     &nbsp; &nbsp;static class Sub extends Base {
    ​
     &nbsp; &nbsp; &nbsp; &nbsp;@Override
     &nbsp; &nbsp; &nbsp; &nbsp;void fun(int price, int[] discounts) {
     &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;System.out.println("Sub....fun");
     &nbsp; &nbsp; &nbsp;  }
     &nbsp;  }
    }
    

    注意看注释的内容是有问题的。

    事实上,base对象是把子类对象Sub做了向上转型,形参列表是由父类决定的,由于是变长参数,在编译时,“base.fun(100,50)”中的“50”这个实参会被编译器“猜测”而编译成“{50}”数组,再由子类Sub执行。

    我们再来看看直接调用子类的情况,这时编译器并不会把“50”做类型转换,因为数组本身也是一个对象,编译器还没有聪明到要在两个没有继承关系的类之间做转换,要知道Java是要求严格的类型匹配的,类型不匹配编译器自然就会拒绝执行,并给予错误提示。

建议7:警惕自增的陷阱
  • count=count++;操作时JVM首先将count原值拷贝到临时变量区,再执行count加1,之后再将临时变量区的值赋给count,所以count一直为0或者某个初始值。C++中count=count++;与count++等效,而PHP与Java类似

    public class Suggest7 {
     &nbsp; &nbsp;public static void main(String[] args) {
     &nbsp; &nbsp; &nbsp; &nbsp;int count = 0;
     &nbsp; &nbsp; &nbsp; &nbsp;for (int i = 0; i < 10; i++) {
     &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;count = count++;
     &nbsp; &nbsp; &nbsp;  }
     &nbsp; &nbsp; &nbsp; &nbsp;System.out.println("count== " + count);
     &nbsp;  }
    }
    
建议8:不要让旧语法困扰你
  • Java中抛弃了C语言中的 goto 语法,但是还保留了该关键字,只是不进行语义处理,const 关键字同样类似。

    public class Suggest8 {
     &nbsp; &nbsp;public static void main(String[] args) {
     &nbsp; &nbsp; &nbsp; &nbsp;// 数据定义及初始化
     &nbsp; &nbsp; &nbsp; &nbsp;int fee = 200;
     &nbsp; &nbsp; &nbsp; &nbsp;// 其他业务处理
     &nbsp; &nbsp; &nbsp; &nbsp;saveDefault:save(fee);
     &nbsp;  }
    ​
     &nbsp; &nbsp;static void saveDefault() {}
    ​
     &nbsp; &nbsp;static void save(int fee) {}
    }
    

    Java中虽然没有了goto关键字,但是扩展了break和continue关键字,它们的后面都可以加上标号做跳转,完全实现了goto功能,同时也把goto的诟病带了进来,所以我们在阅读大牛的开源程序时,根本就看不到 break或continue后跟标号的情况,甚至是break和continue都很少看到,这是提高代码可读性的一剂良药,旧语法就让它随风而去吧!

建议9:少用静态导入
  • Java5引入的静态导入语法import static,使用静态导入可以减少程序字符输入量,但是会带来很多代码歧义,省略的类约束太少,显得程序晦涩难懂。

    import java.text.NumberFormat;
    ​
    import static java.lang.Math.PI;
    import static java.lang.Double.*;
    import static java.lang.Integer.*;
    import static java.text.NumberFormat.*;
    ​
    public class Suggest9 {
    ​
     &nbsp; &nbsp;// 计算圆面积
     &nbsp; &nbsp;public static double calCircleArea(double r) {
     &nbsp; &nbsp; &nbsp; &nbsp;return Math.PI * r * r;
     &nbsp;  }
    ​
     &nbsp; &nbsp;// 计算圆面积(静态导入的作用是把Math类中的PI常量引入到本地中)
     &nbsp; &nbsp;public static double calCircleArea1(double r) {
     &nbsp; &nbsp; &nbsp; &nbsp;return PI * r * r;
     &nbsp;  }
    ​
     &nbsp; &nbsp;// 计算球面积
     &nbsp; &nbsp;public static double calBallArea(double r) {
     &nbsp; &nbsp; &nbsp; &nbsp;return 4 * PI * r * r;
     &nbsp;  }
    ​
     &nbsp; &nbsp;// 计算球面积
     &nbsp; &nbsp;public static double calBallArea1(double r) {
     &nbsp; &nbsp; &nbsp; &nbsp;return 4 * Math.PI * r * r;
     &nbsp;  }
    ​
     &nbsp; &nbsp;public static void main(String[] args) {
     &nbsp; &nbsp; &nbsp; &nbsp;double s = PI * parseDouble("1");
     &nbsp; &nbsp; &nbsp; &nbsp;NumberFormat numberFormat = getInstance();
     &nbsp; &nbsp; &nbsp; &nbsp;numberFormat.setMaximumFractionDigits(parseInt("2"));
     &nbsp; &nbsp; &nbsp; &nbsp;formatMessage(numberFormat.format(s));
     &nbsp;  }
     &nbsp; &nbsp;// 格式化消息输出
     &nbsp; &nbsp;private static void formatMessage(String ans) {
     &nbsp; &nbsp; &nbsp; &nbsp;System.out.println("圆面积是: " + ans);
     &nbsp;  }
    }
    

    对于静态导入, 一定要遵循两个规则:

    • 不使用 *(星号) 通配符, 除非是导入静态常量类(只包含常量的类或接口)。

    • 方法名是具有明确、清晰表象意义的工具类。

建议10:不要在本类中覆盖静态导入的变量和方法
  • 例如静态导入Math包下的PI常量,类属性中又定义了一个同样名字PI的常量。编译器的“最短路径原则”将会选择使用本类中的PI常量。本类中的属性,方法优先。如果要变更一个被静态导入的方法,最好的办法是在原始类中重构,而不是在本类中覆盖

    ​
    import static java.lang.Math.PI;
    import static java.lang.Math.abs;
    ​
    public class Suggest10 {
     &nbsp; &nbsp;public static void main(String[] args) {
     &nbsp; &nbsp; &nbsp; &nbsp;demo1();
     &nbsp; &nbsp; &nbsp; &nbsp;demo2();
     &nbsp;  }
    ​
     &nbsp; &nbsp;private static void demo1() {
     &nbsp; &nbsp; &nbsp; &nbsp;System.out.println("PI= " + PI);
     &nbsp; &nbsp; &nbsp; &nbsp;System.out.println("abs(100)=" + abs(100));
     &nbsp;  }
    ​
     &nbsp; &nbsp;public static void demo2() {
    ​
     &nbsp; &nbsp; &nbsp; &nbsp;final &nbsp; String PI = "祖冲之";
    ​
     &nbsp; &nbsp; &nbsp; &nbsp;System.out.println("PI= " + PI);
     &nbsp; &nbsp; &nbsp; &nbsp;System.out.println("abs(100)=" + abs1(100));
     &nbsp;  }
        // 可改成abs 调试
     &nbsp; &nbsp;public static int abs1(int abs) {
     &nbsp; &nbsp; &nbsp; &nbsp;return 0;
     &nbsp;  }
    }
    ​
    
建议11:养成良好的习惯,显式声明UID
  • 显式声明serialVersionUID可以避免序列化和反序列化中对象不一致,JVM根据serialVersionUID来判断类是否发生改变。隐式声明由编译器在编译的时候根据包名、类名、继承关系等诸多因子计算得出,极其复杂,算出的值基本唯一。

建议12:避免用序列化类在构造函数中为不变量赋值
  • 在序列化类中,不适用构造函数为final变量赋值)(**序列化规则1:**如果final属性是一个直接量,在反序列化时就会重新计算;**序列化规则2:**反序列化时构造函数不会执行;**反序列化执行过程:**JVM从数据流中获取一个Object对象,然后根据数据流中的类文件描述信息(在序列化时,保存到磁盘的对象文件中包含了类描述信息,不是类)查看,发现是final变量,需要重新计算,于是引用Person类中的name值,而此时JVM又发现name没有赋值(因为反序列化时构造函数不会执行),不能引用,于是它不再初始化,保持原始值状态。整个过程中需要保持serialVersionUID相同
建议13:避免为final变量复杂赋值
  • 类序列化保存到磁盘上(或网络传输)的对象文件包括两部分:1、类描述信息:包括包路径、继承关系等。注意,它并不是class文件的翻版,不记录方法、构造函数、static变量等的具体实现。2、非瞬态(transient关键字)和非静态(static关键字)的实例变量值。总结:反序列化时final变量在以下情况下不会被重新赋值:1、通过构造函数为final变量赋值;2、通过方法返回值为final变量赋值;3、final修饰的属性不是基本类型
建议14:使用序列化类的私有方法巧妙解决“部分属性持久化问题”
  • 部分属性持久化问题解决方案1:把不需要持久化的属性加上瞬态关键字(transient关键字)即可,但是会使该类失去了分布式部署的功能。方案2:新增业务对象。方案3:请求端过滤。方案4:变更传输契约,即覆写writeObject和readObject私有方法,在两个私有方法体内完成部分属性持久化
建议15:break万万不可忘
  • switch语句中,每一个case匹配完都需要使用break关键字跳出,否则会依次执行完所有的case内容。

    public class Suggest15 {
     &nbsp; &nbsp;public static void main(String[] args) {
     &nbsp; &nbsp; &nbsp; &nbsp;System.out.println("2 = " + toChineseNumberCase(2));
     &nbsp;  }
    ​
     &nbsp; &nbsp;private static String toChineseNumberCase(int value) {
     &nbsp; &nbsp; &nbsp; &nbsp;String chineseNumberCase ="";
     &nbsp; &nbsp; &nbsp; &nbsp;switch (value) {
     &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;case 0: chineseNumberCase = "零";
     &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;case 1: chineseNumberCase = "壹";
     &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;case 2: chineseNumberCase = "贰";
     &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;case 3: chineseNumberCase = "叁";
     &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;case 4: chineseNumberCase = "肆";
     &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;case 5: chineseNumberCase = "伍";
     &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;case 6: chineseNumberCase = "陆";
     &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;case 7: chineseNumberCase = "柒";
     &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;case 8: chineseNumberCase = "捌";
     &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;case 9: chineseNumberCase = "玖";
     &nbsp; &nbsp; &nbsp;  }
     &nbsp; &nbsp; &nbsp; &nbsp;return chineseNumberCase;
     &nbsp;  }
    }
    

    对于此类问题最简单的解决办法: 修改IDE的警告级别

建议16:易变业务使用脚本语言编写
  • 脚本语言:都是在运行期解释执行。脚本语言三大特性:

    1、灵活:动态类型;

    2、便捷:解释型语言,不需要编译成二进制,不需要像Java一样生成字节码,依靠解释执行,做到不停止应用变更代码

    3、简单:部分简单。Java使用ScriptEngine执行引擎来执行JavaScript脚本代码

建议17:慎用动态编译
  • 好处:更加自如地控制编译过程。很少使用,原因:静态编译能够完成大部分工作甚至全部,即使需要使用,也有很好的替代方案,如JRuby、Groovy等无缝的脚本语言。动态编译注意以下4点:

    • 1、在框架中谨慎使用:debug困难,成本大;

    • 2、不要在要求高性能的项目中使用:需要一个编译过程,比静态编译多了一个执行环节;

    • 3、动态编译要考虑安全问题:防止恶意代码;

    • 4、记录动态编译过程

建议18:避免instanceof非预期结果
  • instanceof用来判断一个对象是否是一个类的实例,只能用于对象的判断,不能用于基本类型的判断(编译不通过),instanceof操作符的左右操作数必须有继承或实现关系,否则编译会失败。

    例:null instanceof String返回值是false,instanceof特有规则,若左操作数是null,结果就直接返回false,不再运算右操作数是什么类

    public class Suggest18 {
     &nbsp; &nbsp;public static void main(String[] args) {
     &nbsp; &nbsp; &nbsp; &nbsp;// “String”是一个字符串,字符串又继承了对象,那当然是返回true了。
     &nbsp; &nbsp; &nbsp; &nbsp;boolean b1 = "String" instanceof Object;
     &nbsp; &nbsp; &nbsp; &nbsp;// 类对象就是它的实例
     &nbsp; &nbsp; &nbsp; &nbsp;boolean b2 = new String() instanceof String;
     &nbsp; &nbsp; &nbsp; &nbsp;// Object 是父类, 其对象当然不是String类的实例
     &nbsp; &nbsp; &nbsp; &nbsp;boolean b3 = new Object() instanceof String;
     &nbsp; &nbsp; &nbsp; &nbsp;// 编译失败 instance 只能用于对象的判断,不能用于基本类型的判断
     &nbsp; &nbsp; &nbsp; &nbsp;// boolean b4 = 'A' instanceof Character;
     &nbsp; &nbsp; &nbsp; &nbsp;// 左边是false ,直接返回 false
     &nbsp; &nbsp; &nbsp; &nbsp;boolean b5 = null instanceof String;
     &nbsp; &nbsp; &nbsp; &nbsp;// 即使做类型转换也还是 null
     &nbsp; &nbsp; &nbsp; &nbsp;boolean b6 = (String) null instanceof String;
     &nbsp; &nbsp; &nbsp; &nbsp;// Date 和 String 没有继承或者实现关系, 编译通不过
     &nbsp; &nbsp; &nbsp; &nbsp;// boolean b7 = new Date() instanceof String;
     &nbsp; &nbsp; &nbsp; &nbsp;// 编译通过, T 是 Object, "t instanceof Date" -> "Object instanceof Date"
     &nbsp; &nbsp; &nbsp; &nbsp;boolean b8 = new GenericClass<String>().isDateInstance("");
     &nbsp; &nbsp; &nbsp; &nbsp;System.out.println("b1 " + b1);
     &nbsp; &nbsp; &nbsp; &nbsp;System.out.println("b2 " + b2);
     &nbsp; &nbsp; &nbsp; &nbsp;System.out.println("b3 " + b3);
     &nbsp; &nbsp; &nbsp; &nbsp;System.out.println("b5 " + b5);
     &nbsp; &nbsp; &nbsp; &nbsp;System.out.println("b6 " + b6);
     &nbsp; &nbsp; &nbsp; &nbsp;System.out.println("b8 " + b8);
     &nbsp;  }
    ​
     &nbsp; &nbsp;static class GenericClass<T> {
     &nbsp; &nbsp; &nbsp; &nbsp;// 判断是否是Date类型
     &nbsp; &nbsp; &nbsp; &nbsp;public boolean isDateInstance(T t) {
     &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;return t instanceof Date;
     &nbsp; &nbsp; &nbsp;  }
     &nbsp;  }
    }
    ​
    
    b1 true
    b2 true
    b3 false
    b5 false
    b6 false
    b8 false
    
建议19:断言绝对不是鸡肋
  • 防御式编程中经常使用断言(Assertion)对参数和环境做出判断。断言是为调试程序服务的。

    两个特性:

    1. 默认assert不启用;

    2. assert抛出的异常AssertionError是继承自Error的

    assert虽然是做断言的,但不能将其等价于if…else…这样的条件判断,它在以下两种情况不可使用 :

    1. 在对外公开的方法中

      我们知道防御式编程最核心的一点就是:所有的外部因素(输入参数、环境变量、上下文)都是“邪恶”的,都存在着企图摧毁程序的罪恶本源,为了抵制它,我们要在程序中处处检验,满地设卡,不满足条件就不再执行后续程序,以保护主程序的正确性,处处设卡没问题,但就是不能用断言做输入校验,特别是公开方法。我们来看一个例子:

      public class Suggest19 {
       &nbsp; &nbsp;public static void main(String[] args) {
       &nbsp; &nbsp; &nbsp; &nbsp;StringUtils.encode(null);
       &nbsp;  }
      ​
      }
      class StringUtils {
       &nbsp; &nbsp;public static String encode(String str) {
       &nbsp; &nbsp; &nbsp; &nbsp;assert str != null : "加密的字符串为null";
       &nbsp; &nbsp; &nbsp; &nbsp;return str;
       &nbsp;  }
      }
      

      encode方法对输人参数做了不为空的假设,如果为空,则抛出AssertionError错误,但这段程序存在一个严重的问题,

      encode是一个public方法,这标志着是它对外公开的,任何一个类只要能够传递一个String类型的参数(遵守契约)就可以调用,

      但是Client类按照规范和契约调用enocde方法,却获得了一个AssertionError错误信息,是谁破坏了契约协定?—一是encode方法自己。

    2. 在执行逻辑代码的情况下

      assert 的支持是可选的,在开发时可以让它运行, 但在生产系统中则不需要其运行了(以便提高性能), 因此在 assert的布尔表达式中不能执行逻辑代码, 否则会因为环境不同而产生不同的逻辑。

建议20:不要只替换一个类
  • 发布应用系统时禁止使用类文件替换方式,整体WAR包发布才是完全之策)(Client类中调用了Constant类中的属性值,如果更改了Constant常量类属性的值,重新编译替换。

    而不改变或者替换Client类,则Client中调用的Constant常量类的属性值并不会改变。

    **原因:**对于final修饰的基本类型和String类型,编译器会认为它是稳定态(Immutable Status),所以在编译时就直接把值编译到字节码中了,避免了再运行期引用,以提高代码的执行效率。而对于final修饰的类(即非基本类型),编译器认为它是不稳定态(Mutable Status),在编译时建立的则是引用关系(该类型也叫作Soft Final),如果Client类引入的常量是一个类或实例,即使不重新编译也会输出最新值

    class Constant {
     &nbsp; &nbsp;public final static int MAX_AGE = 150;
    }
    ​
    public class Suggest20 {
    ​
     &nbsp; &nbsp;public static void main(String[] args) {
     &nbsp; &nbsp; &nbsp; &nbsp;System.out.println("人类寿命权限是: " + Constant.MAX_AGE);
     &nbsp;  }
    }
    
内容大纲
批注笔记
编写高质量代码:改善Java程序的151个建议 | 第一章 Java开发中通用的方法和准则
ArticleBot
z
z
z
z
主页
Git管理
文章
云文档
留言墙
AI文档