Java 拾遗

1、选择表达式中的类型转换

public class Test {
          public void static main(String args[]){
            int i = 5;
            System.out.println("Vlaue Is " + ((a<5) ? 10.9:9));
          }
}

当前程序的输出是什么？其实很容易得出输出9的错误结论；因为Java会根据精度自动进行类型转换，所以此时9应当为9.0。

public class Test {
    public static void main (String args[]) {
        char x = 'x';
        int  i = 10;
        System.out.println( false?  i:x );
        System.out.println( false? 10:x );
    }
}

同样，上述代码的输出是什么呢。。第一行根据上一个例子，知道Java会进行类型转换，最后输出的结果应当是‘X’转化为int型的结果，也就是120.

那第二行的输出呢？根据Java编程规范：当后两个表达式有一个是常量表达式（本例中是10），另一个是T类型的变量，那么当常量可以被表达为T类型时，

输出结果为T类型。10是常量，可以被char表示，输出结果为char类型。

2、短路运算与非短路运算

短路运算：编译器对 && 和 || 这两个运算做了优化，凡&&前面为FALSE的，&&后面的表达式都不被执行，如果 || 前面的结果为TRUE，|| 后面的表达式都

不被执行。

非短路运算：布尔逻辑运算符则没有这个特点，在 & 和 | 前面，无论运算结果如何，后面的运算都将继续。

        int m = 5;
        int n = 5;
        if((m != 5) && (n++ == 5))    //(n++ == 5)不会执行，所以m=5,n=5
            System.out.println("A.n = "+n);
 
        m = n = 5;
        if((m != 5) & (n++ == 6))     //两个都要执行，所以此时m=5,n=6
            System.out.println("B.n = "+n);
 
        m = n = 5;
        if((m == 5) || (n++ == 6))    // 第一个执行 m=5,n=5
            System.out.println("B.n = "+n);
 
        int a = 1;
        int b = 2;
        int c = a&b;
        System.out.println("a&b " + c);  //按位操作 所以C=0

3、异常

　　（1）什么是异常

在Java程序运行时，会出现一些非正常的状况，这种状况被称为运行错误；其性质可以分为错误和异常。Java程序中抛出(Throw)的异常都必须从Throwable中

派生而来。类Throwable有两个直接的子类：Error和Exception。Java异常对应的类为Exception类，它的对象是Java程序处理或者抛弃的的对象，Exception有

各种子类来应对Java程序中出现的异常。Java要求必须捕获或者声明所有非运行时异常，但对运行时异常可以不做处理。其中RuntimeException代表Java运行时

异常，由JVM产生，原因是编程错误。其他为非运行时异常，原因是遇到意外情况，比如输入输出错误。

（2）处理异常的关键字

　 try {} catch{} finally{} throw throws是五个Java处理异常的关键字。finally对应的语句是必然会被执行的，catch{}块可以有多个，finally{}语句块只能

有一个。若有多个catch{}块，只有其中一个会被执行，而且匹配的顺序是自上而下的。

throw关键字用于方法内部，用来抛出一个Throwable类型的异常。如果抛出了异常检查，还应该在头部声明方法可能抛出的异常类型。方法的调用者也必须检查

处理抛出的异常。如果所有的方法都层层上抛获取的异常，最终JVM会进行处理。若抛出的是Error或者RuntimeException，则可以针对性的处理。

throws用于方法外的方法声明部分，用来声明方法可能会抛出的异常，仅当抛出了异常检查，该方法调用者才必须处理或者重新抛出该异常。当方法的调用者

无力处理异常的时候，应该继续抛出异常。

4、final，finally，finalize

　　final可以修饰成员，方法，类。finally属于异常处理的关键字。finalize用于不易控制，并且非常重要的资源的释放。

（1）final修饰成员。保证这些成员只被使用不被改变，初始的地方有两个：构造函数中赋予初值，定义时被赋予初值，二选一。

　  （2）final修饰方法，只能被重用，不可被重写(override)。

　  （3）final修饰类，不再派生子类，一个类不能即被声明为abstract，也被声明为final。

finally{}用来执行清除操作，如果抛出一个异常，那么相应的catch{}就会执行，最终代码会进入finally{}（如果有的话）。

finalize是方法名。Java允许finalize()在垃圾收集器工作前完成一些必要的清理工作。

5、基本数据类型与包装类之间的区别

　  基本的数据类型有int、float、double，char等，他们对应的包装类为Integer，Float，Double，Character。那么基本类型与包装类之间的差别基本可以归纳为

俩种。

　　第一，基本的数据类型不能通过方法的调用完成类型之间的转换。比如一个字符串“123”，如果将其转化为整数123，我们在代码里通常的做法

是Integer.parseInt("123")，而不可以是（int）“123”，所以包装类为类型转换等提供了很多方法，当然这些包装类还提供其他的方法，比如Integer还提供二进制

比特位的一些操作。相关的方法可以参考API。

　　第二，在泛型编程中，初始化Collection的子类时，需要使用包装类指定其中的数据类型，基本的数据类型是不被接受的。

　　比如 List<Integer> seq = new List<Integer>();

6、== 与equals之间的区别

对于==，使用==比较基本数据类型(byte,short,char,int,long,float,double,boolean)，比较的就是值，如果这些基本类型的值是一致的，就返回TRUE，如果

==两边是引用类型，==比较的是二者的内存地址是否一致，所以除非对应内存地址完全一致，否则返回值均为FALSE。

A.equals(B)是比较A，B两者之间的“内容”是否一致。equals()继承于Object的实现，在Object的实现的比较行为就是比较两者之间的内存地址，如果类不重写

自己的equals方法，那比较的结果其实就是 == 的运算结果。

person  p1 = new person("A",100);  person p2 = new person("A",100);

p1 == p2 返回 FALSE，p1.equals(p2) 返回FALSE。 也就是说此时的equals并没有按照我们的预想去比较“内容”，所以如果想要实现特定的equals，必须自

己去实现。当然很多类覆写了equals方法，比如String。String s1 = new String("OK");     String s2 = new String("OK"); s1 == s2 返回 FALSE，

s1.equals(s2) 返回TRUE。

因此使用== 和使用equals的时机需要仔细的权衡，必要的时候还要覆写对象的equals方法，来实现具体的比较功能。