牛客刷题-Java专项练习-难点整理（一）

1.变量a是一个64位有符号的整数，初始值用16进制表示为：0Xf000000000000000；
 变量b是一个64位有符号的整数，初始值用16进制表示为：0x7FFFFFFFFFFFFFFF。 
 则a-b的结果用10进制表示为多少？（）

	A.1
	B.-(2^63 + 2^62 + 2^61 + 1)
	C.2^63 + 2^62 + 2^61 + 1
	D.error
	
	正确答案：C

解题过程：

在寄存器中用补码存，所以原来的数是补码

a：0Xf000-0000-0000-0000（负数） （负数的补码是原码除符号位外取反，然后 +1）
补码：1111 0000 ~ 
原码：1001 0000 ~ 

b：0x7FFF-FFFF-FFFF-FFFF——（正数）（正数的补码就是本身）
补码：0111 1111 ~ 
原码：0111 1111 ~ 

a-b：（CPU只有加法器，遇到减法就用加法代替。将减数全部取反，然后 +1，转化为被减数与转换后的数的加法）
a补码 - b补码
	补码：  1111 0000 ~ 
			-
	补码：  0111 1111 ~
			=
	补码：  1111 0000 ~
			+
	补码：  1000 0000 ~ 0001
			=
	补码：1 0111 0000 ~  0001  （高位溢出全部丢弃）
	补码：0111 0000 ~ 0001 （实际得到的补码）
	原码：0111 0000 ~ 0001
	
a-b = 0x7000-0000-0000-0001
    （二进制）： 0111 0000 ~ 0001B
    （十进制）：2^63 + 2^62 + 2^61 + 1

2.What will be printed when you execute the following code?

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

正确答案：B

解题过程：

Java类初始化过程：
				①初始化父类静态成员变量和静态代码块
				②初始化子类静态成员变量和静态代码块
				③初始化父类普通成员变量和代码块，执行父类构造方法
				④初始化子类普通成员变量和代码块，执行子类构造方法
本题初始化过程：
				①初始化父类成员变量和代码块：C c = new C(); 调用 C 的无惨构造方法，输出 C；
				②super("B"); 调用父类有参构造方法，不调用无参构造方法，输出 B；
				③输出 B；
输出结果：CBB

4.假定Base b = new Derived（）; 调用执行b.methodOne（）后，输出结果是什么？

public class Base
{
   public void methodOne()
   {
      System.out.print("A");
      methodTwo();
   }

   public void methodTwo()
   {
      System.out.print("B");
   }
}

public class Derived extends Base
{
   public void methodOne()
   {
      super.methodOne();
      System.out.print("C");
   }

   public void methodTwo()
   {
      super.methodTwo();
      System.out.print("D");
   }
}

A.ABDC
B.AB
C.ABCD
D.ABC

正确答案：D

解题过程
执行顺序如下：

public class Base
{
   public void methodOne()	//（3）
   {
      System.out.print("A");	//（4）
      methodTwo();	//（5），此时调用子类重写父类的覆盖方法
   }

   public void methodTwo()	//（9）
   {
      System.out.print("B");	//（10）
   }
}

public class Derived extends Base
{
   public void methodOne()	//（1）
   {
      super.methodOne();	//（2）
      System.out.print("C");	//（6）
   }

   public void methodTwo()	//（7），重写父类方法
   {
      super.methodTwo();	//（8）
      System.out.print("D");	//（11）
   }
}

输出结果：ABDC