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.没有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.如果参数个数相同，那么参数的类型或者参数的顺序必须不同。
三.方法的返回类型、修饰符可以相同，也可不同。
二.方法的参数表必须不同，包括参数的类型或个数，以此区分不同的方法体。
1.如果参数个数不同，就不管它的参数类型了！
2.如果参数个数相同，那么参数的类型或者参数的顺序必须不同。
三.方法的返回类型、修饰符可以相同，也可不同。