1.代码输出结果是(D)
public class Test {
public static void main(String [] args){
System.out.println(new B().getValue());
}
static class A{
protected int value;
public A(int v) {
setValue(v);
}
public void setValue(int value){
this.value = value;
}
public int getValue(){
try{
value++;
return value;
} catch(Exception e){
System.out.println(e.toString());
} finally {
this.setValue(value);
System.out.println(value);
}
return value;
}
}
static class B extends A{
public B() {
super(5);
setValue(getValue() - 3);
}
public void setValue(int value){
super.setValue(2 * value);
}
}
}
A.11 17 34
B.22 74 74
C.6 7 7
D.22 34 17
解析:这题总结几点:
1.try中有return 下面的return都不会再执行
2.try中的return 在确认要返回时 那个值就锁定了 即使finally对该值改变也不会改变结果
3.子类重写父类的方法时 调用的方法一定是子类的方法
2.下面的程序 编译运行后,在屏幕上显示的结果是(A)
public class test {
public static void main(String args[]) {
int x,y;
x=5>>2;
y=x>>>2;
System.out.println(y);
}
}
A.0
B.2
C.5
D.80
解析:5二进制 0101 右移两位>> 0001,再右移两位>>>0000
>>:带符号右移。正数右移高位补0,负数右移高位补1。比如:4 >> 1,结果是2;-4 >> 1,结果是-2。-2 >> 1,结果是-1。
>>>:无符号右移。无论是正数还是负数,高位通通补0。
3…有如下代码:请写出程序的输出结果。(B)
public class Test
{
public static void main(String[] args)
{
int x = 0;
int y = 0;
int k = 0;
for (int z = 0; z < 5; z++) {
if ((++x > 2) && (++y > 2) && (k++ > 2))
{
x++;
++y;
k++;
}
}
System.out.println(x + ”” +y + ”” +k);
}
}
A.432
B.531
C.421
D.523
解析:
第一次:0
1 0 0
第二次:1
2 0 0
第三次:2
3 1 0
第四次:3
4 2 0
第五次:4
5 3 1
4.给出以下代码,请给出结果.(B)
class Two{
Byte x;
}
class PassO{
public static void main(String[] args){
PassO p=new PassO();
p.start();
}
void start(){
Two t=new Two();
System.out.print(t.x+””);
Two t2=fix(t);
System.out.print(t.x+” ” +t2.x);
}
Two fix(Two tt){
tt.x=42;
return tt;
}
}
A.null null 42
B.null 42 42
C.0 0 42
D.0 42 42
解析:Byte 包装类 默认NULL
Two t2=fix(t)之后 t和t2 其实是同一个对象 值当然相等
5.
byte b1=1,b2=2,b3,b6,b8;
final byte b4=4,b5=6,b7;
b3=(b1+b2); /语句1/
b6=b4+b5; /语句2/
b8=(b1+b4); /语句3/
b7=(b2+b5); /语句4/
System.out.println(b3+b6);
下列代码片段中,存在编译错误的语句是(BCD)
A.语句2
B.语句1
C.语句3
D.语句4
解析:
------------知识点------------
Java表达式转型规则由低到高转换:
1、所有的byte,short,char型的值将被提升为int型;
2、如果有一个操作数是long型,计算结果是long型;
3、如果有一个操作数是float型,计算结果是float型;
4、如果有一个操作数是double型,计算结果是double型;
5、被fianl修饰的变量不会自动改变类型,当2个final修饰相操作时,结果会根据左边变量的类型而转化。
--------------解析--------------
语句1错误:b3=(b1+b2);自动转为int,所以正确写法为b3=(byte)(b1+b2);或者将b3定义为int;
语句2正确:b6=b4+b5;b4、b5为final类型,不会自动提升,所以和的类型视左边变量类型而定,即b6可以是任意数值类型;
语句3错误:b8=(b1+b4);虽然b4不会自动提升,但b1仍会自动提升,所以结果需要强转,b8=(byte)(b1+b4);
语句4错误:b7=(b2+b5); 同上。同时注意b7是final修饰,即只可赋值一次,便不可再改变。
6.对于如下代码段
class A{
public A foo(){return this;}
}
class B extends A{
public A foo(){
return this;
}
}
class C extends B
{
_______
}
可以放入到横线位置,使程序正确编译运行,而且不产生错误的选项是( C
A.public void foo(){}
B.public int foo(){return 1;}
C.public A foo(B b){return b;}
D.public A foo(){return A;}
解析:
复习一下子类方法重写父类方法遵循“两同两小一大”的规则
子类覆盖父类要遵循“两同两小一大”
“两同”即方法名相同,形参列表相同
“两小”指的是子类方法返回值类型应比父类方法返回值类型更小或相等,子类方法声明抛出的异常类应比父类方法声明抛出的异常类更小或相等。
A.public void foo(){}
返回值类型与父类不一致,所以不可能是方法的重写。又因为方法名相同,那么只能是方法重载,而方法重载有需要满足三个条件:形参个数、顺序、类型必须有一者不同,A选项都不满足,错
B.public int foo(){return 1;}
与A选项一样
C.public A foo(B b){return b;}
返回值类型与父类相同,但由于参数列表不同,所以是对父类方法的重载
D.public A foo(){return A;}
D 选项 返回值中A未定义,编译错误。D错误。
语法错误
7.What will be printed when you execute the following code? (B)
class C {
C() {
System.out.print("C");
}
}
class A {
C c = new C();
A() {
this("A");
System.out.print("A");
}
A(String s) {
System.out.print(s);
}
}
class Test extends A {
Test() {
super("B");
System.out.print("B");
}
public static void main(String[] args) {
new Test();
}
}
A.BB
B.CBB
C.BAB
D.None of the above
解析:
初始化过程是这样的:
1.首先,初始化父类中的静态成员变量和静态代码块,按照在程序中出现的顺序初始化;
2.然后,初始化子类中的静态成员变量和静态代码块,按照在程序中出现的顺序初始化;
3.其次,初始化父类的普通成员变量和代码块,在执行父类的构造方法;
4.最后,初始化子类的普通成员变量和代码块,在执行子类的构造方法;
(1)初始化父类的普通成员变量和代码块,执行 C c = new C(); 输出C
(2)super(“B”); 表示调用父类的构造方法,不调用父类的无参构造函数,输出B 为什么不执行无参构造方法呢? 我认为父类的构造方法所谓的执行其实是在子类构造方法里面都有一个默认的super() 调用无参构造方法,如果指定了super("") 就调用指定的super
如果删掉super(“B”) 则默认执行super(); 结果是CAAB
(3) System.out.print(“B”);
所以输出CBB