Java这点事

1--代码片段： 

1 2 3 4 5

byte b1=1,b2=2,b3,b6;  final byte b4=4,b5=6;  b6=b4+b5;  b3=(b1+b2);  System.out.println(b3+b6);

关于上面代码片段叙述正确的是（）

• 输出结果：13
• 语句：b6=b4+b5编译出错
• 语句：b3=b1+b2编译出错
• 运行期抛出异常

 

分析：

表达式的数据类型自动提升, 关于类型的自动提升，注意下面的规则。

①所有的byte,short,char型的值将被提升为int型；

②如果有一个操作数是long型，计算结果是long型；

③如果有一个操作数是float型，计算结果是float型；

④如果有一个操作数是double型，计算结果是double型；

而声明为final的变量会被JVM优化，第6行相当于 b6 = 10

 

没有final修饰的变量相加后会被自动提升为int型，与目标类型byte不相容，需要强制转换（向下转型）。

 

C.

被final修饰的变量是常量，这里的b6=b4+b5可以看成是b6=10；在编译时就已经变为b6=10了

而b1和b2是byte类型，java中进行计算时候将他们提升为int类型，再进行计算，b1+b2计算后已经是int类型，赋值给b3，b3是byte类型，类型不匹配，编译不会通过，需要进行强制转换。

Java中的byte，short，char进行计算时都会提升为int类型。

 

1.需要强制转换（向下转型）。
2.没有final修饰的变量相加后会被自动提升为int型，与目标类型byte不相容，要向下转型。

 

 

 

2--下面代码运行结果是（）

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

public class Test{      public int add(int a,int b){             try {              return a+b;                }          catch (Exception e) {               System.out.println("catch语句块");          }          finally{               System.out.println("finally语句块");          }          return 0;     }       public static void main(String argv[]){           Test test =new Test();           System.out.println("和是："+test.add(9, 34));       } }

• catch语句块，和是：43
• 编译异常
• finally语句块，和是：43
• 和是：43，finally语句块

分析：

答案是C

对于try块中的return，先计算return 后面的表达式，缓存结果

跳到finally语句块中执行，如果finally语句块中有return语句，则不会再去执行try中的语句。

如果finally中没有return语句，则会再次去try语句块中执行return

 

 

3--以下java程序代码，执行后的结果是（）

1 2 3 4

java.util.HashMap map=new java.util.HashMap();  map.put("name",null);       map.put("name","Jack"); System.out.println(map.size());

• 0
• null
• 1
• 2

分析：

C.HashMap是Map接口的实现类，并且不保证元素的顺序恒久不变，它的底层使用的是数组和链表，通过hashCode()方法和equals方法保证键的唯一性

HashMap允许null键和null值

使用put方法向HashMap中添加元素时，如果键不存在，则添加该元素，并返回null;如果键已经存在，则把该键对应的值进行覆盖，返回原来的键，由于键都是"name"，所以第二次添加的会把第一次的值覆盖，并返回第一次的键，所以HashMap中还是只有一个元素

 

Map Set无重复，List按顺序存储。

 

 

 

4--

执行以下程序后的输出结果是（）

1 2 3 4 5 6 7 8 9 10 11

public class Test { public static void main(String[] args) {     StringBuffer a = new StringBuffer("A");      StringBuffer b = new StringBuffer("B");      operator(a, b);      System.out.println(a + "," + b);  }  public static void operator(StringBuffer x, StringBuffer y) {      x.append(y); y = x;  } }

• A,A
• A,B
• B,B
• AB,B

分析：

a,b是对象的引用，指向堆内存，将a，b两个引用传给x，y，执行x.append(y)，改变了x引用指向的堆内存的存储内容，变为AB， y = x，表示引用y,指向引用x指向的存储区域，没有改变引用b，指向的存储空间的内容。

x,y是a,b的副本，x.append(y)使得AB在一起，而y=x后，y指向AB，方法结束后x,y消亡，故a-AB,b-B;

 

 

5--以下方法，哪个不是对add方法的重载?

1 2 3 4

public class Test {     public void add( int x,int y,int z){} }

• pubilc int add(int x,int y,float z){return 0;}
• pubilc int add(int x,int y,int z){return 0;}
• pubilc void add(int x,int y){}
• 以上都不是

分析：

B

方法重载是指在一个类中定义多个同名的方法，但要求每个方法具有不同的参数的类型或参数的个数。

原则如下：

一.方法名一定要相同。
二.方法的参数表必须不同，包括参数的类型或个数，以此区分不同的方法体。
1.如果参数个数不同，就不管它的参数类型了！
2.如果参数个数相同，那么参数的类型或者参数的顺序必须不同。
三.方法的返回类型、修饰符可以相同，也可不同。