java陷阱知多少

1.自增的危险

    @Test
    public void addSelfTest(){
        int count = 0;
        for(int i=0;i<10;i++){
            count = count++;
        }    
       System.out.println("count:"+count);        
    }

输出结果：0

结果不是想象中的10，而是0；原因是对于count = count++;这句代码的理解；从优先级来看，自增（++）运算符的优先级明显比赋值（=）高。但是java中执行这些代码还有一些曲折的故事：步骤：1.在自增之前先把count的值存放到临时变量中，2.count自增，count的值变成1；3.赋值时将临时变量的值赋值给count，count的值重置为0;

注意：在java中要防止count = count++;这样的代码的出现；

 

2.让人摸不着头脑的冒号语法

 public static void main(String[] args) {
          int fee=200;
          saveDefault:save(fee);
     }
    
     static void  saveDefault(){
         System.out.println("This is saveDafault");
     }
     
     static void save(int fee){
         System.out.println("This is save");
     }

孩子，看不懂就回去看看c语言吧

 

3.少用静态导入，如果你不想被骂娘

import static java.lang.Math.*;
import static java.lang.Double.*;
import static java.text.NumberFormat.*;
import java.text.NumberFormat;
import static java.lang.Integer.*;

public class RefusedToStaticImport {
    public static void main(String[] args) {
        double s = PI*parseDouble(args[0]);
        NumberFormat nf = getInstance();
        nf.setMaximumFractionDigits(parseInt(args[1]));
    }
}

能看懂这段操蛋的代码不？你看懂了那你也很奇葩，因为我都不知道getInstance()这东东要获取的是什么的实例，看到不好了，以后就少用吧

 

4.不要在本类中覆盖静态导入的方法和属性，否则，嘿嘿，你会有意想不到的惊喜

 

package Test;
import static java.lang.Math.*;

public class RefuseOverrideStaticImport {
    //覆盖圆周率
    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));
    }
}

 

 

 

5.养成好习惯，显示生成UID（实现序列化的时候）

6.在序列化类中不允许在构造方法中为不变量赋值（非常重要，一不小心，数据会发生错误）

7.千万在要在每一个case后面加上一个break（有程序员因为这个造成重大损失你信吗）

8.易变业务使用脚本语言编写

 

public class TestScript {
    
   public static void main(String[] args) throws ScriptException, NoSuchMethodException {
       test2();
   }
    
   
   public static void test1() throws ScriptException{
       ScriptEngine engine = new ScriptEngineManager().getEngineByName("javascript");  
        Compilable compilable = (Compilable) engine;  
        Bindings bindings = engine.createBindings(); //Local级别的Binding  
        String script = "function add(op1,op2){return op1+op2} add(a, b)"; //定义函数并调用  
        CompiledScript JSFunction = compilable.compile(script); //解析编译脚本函数  
        bindings.put("a", 1);bindings.put("b", 2); //通过Bindings加入参数  
        Object result = JSFunction.eval(bindings);  
        System.out.println(result); //调用缓存着的脚本函数对象，Bindings作为参数容器传入  
   }
   
   
   public static void test2() throws ScriptException, NoSuchMethodException{
       int param = 10;
      //建立一个javascript的执行引擎
       ScriptEngine scriptEngine = new ScriptEngineManager().getEngineByName("javascript"); 
       
     //建立上下文变量
       Bindings bind = scriptEngine.createBindings();
       bind.put("factor", 1);
       scriptEngine.setBindings(bind, ScriptContext.ENGINE_SCOPE);
           scriptEngine.eval("d://test.js");
           if(scriptEngine instanceof Invocable){
               Invocable in = (Invocable)scriptEngine;
               Double result = (Double)in.invokeFunction("square", param);
               System.out.println("number "+param+" square result is "+result);
           }
   }

 

好处就是在运行的时候如果这段业务要改变，那么不必要重启服务器，只需要修改脚本就完了