Java基础题库知识总结

一、try{}catch(){}finally{}

    public int testTry(int a,int b){
        try{
            return a+b;
        }catch (Exception e){
            System.out.println("catch语句块");
        }finally {
            System.out.println("finally语句块");
        }
    }
    public static void main(String[] args) {
        TestStudy testStudy = new TestStudy();
        System.out.println("和是："+testStudy.testTry(1,2));
    }

此处的执行顺序：

1、首先return a+b;把值存入一个临时栈中

2、执行finally，打印输出”finally语句块“

3、由于finally中没有return；所以return返回的值就是之前return a+b;

4、输出”和是：3“

所以总的输出是：finally语句块 和是：3

    public int testTry(int a,int b){
        try{
            return a+b;
        }catch (Exception e){
            System.out.println("catch语句块");
        }finally {
            System.out.println("finally语句块");
            return b-a;
        }
    }
    public static void main(String[] args) {
        TestStudy testStudy = new TestStudy();
        System.out.println("和是："+testStudy.testTry(1,2));
    }

此处的执行顺序：

1、首先return a+b;把值存入一个临时栈中

2、执行finally，打印输出”finally语句块“

3、由于finally中存在return；执行return的值，值为1 ，替换之前存储的值3，所以return返回的值就是之前return b-a;

4、输出”和是：1“

所以总的输出是：finally语句块 和是：1

    public static String str = "";

    public static void a(int i) {
        try {
            if (i % 2 == 0) {
                throw new Exception();
            }
        } catch (Exception e) {
            str += "0";
            return;
        } finally {
            str += "1";
        }
        str += "2";
    }

    public static void main(String[] args) {
        a(1);
        a(2);
        System.out.println(str);
    }

a(1)执行的顺序是：进入finally 1，再12，执行结束

a(2)执行的顺序是：进入catch 0，再进入finally 01，在返回catch中的return，执行结束。

所以结果是1201

    public static Integer str = 0;

    public static void a(int i) {
        try {
            if (i % 2 == 0) {
                throw new Exception();
            }
        } catch (Exception e) {
            str =1 ;
            return;
        } finally {
            str =2;
            return;
        }
    }

    public static void main(String[] args) {
        a(1);
        System.out.println(str);
        a(2);
        System.out.println(str);
    }

a(1)执行的顺序是：进入finally 2，执行结束

a(2)执行的顺序是：进入catch中，str=1，再进入finally str=2，执行return执行结束。

二、>>、>>>运算

public static void main(String[] args) {
        int x,y;
        x=41>>2;
        y=x>>>2;
        System.out.println(x);
        System.out.println(y);
    }

>> 正数：相当于除以右移两位（也是除以4，取整数位）

      负数：例-10，首先二进制位为   1000 1010，负数取反加1，即为1111 0110。右移两位1111 1101，所以现在需要-1（1111 1100），取反1000 0011，为-3。

>>>相当于除以4，留下的整数位

41=101001向右移两位为1010即为10，10>>>2为2

三、JVM创建对象

例子：

String a = “abc”;
String b = “abc”;
String c = new String(“abc”);
String d = c.intern();

这段代码（code）共创建了几个对象？

答：只创建了两个对象。

第一行创建了，（对象的引用变量a存在栈中，到常量池中找有没有“abc”，因为没有，所以直接在常量池中创建“abc”对象，然后栈中的a指向常量池中的“abc”）。

第二行（对象的引用变量b存在栈中）会在常量池中找有没有“abc”，有就把栈中的b指向常量池中的“abc”；没有就在常量池创建“abc”对象，再指向它。第一行常量池中有“abc“了，所以栈中的b直接指向常量池中的“abc”。

第三行，在栈中为c申请一个空间，在堆中开辟空间存放对象“abc”，然后把堆中存放“abc”的地址赋值给c，c指向堆中的“abc”对象。

第四行，先判断常量池中有没有“abc”，因为有，所以直接让栈中的d指向常量池中已经存在的“abc”。如果没有，就将堆中再创一个对象“abc”并返回对象的引用（JDK1.7及之后是这样做，不再拷贝到常量池，而是堆中创建一个类，再直接返回堆中对象的引用）【这里没创对象】