1、A 派生出子类 B ， B 派生出子类 C ，并且在 java 源代码有如下声明：问以下哪个说法是正确的？（D）

1.	A a0=new A();
2.	A a1=new B();
3.	A a2=new C();

A 、只有第一行能通过编译
B 、第1、2行能通过编译，但第3行编译出错
C 、第1、2、3行能通过编译，但第2、3行运行时出错
D 、第1行，第2行和第3行的声明都是正确的

解析：
继承具有传递性，子类可以无条件的向上转型，所以都对~

2、下面代码输出什么？（false）

public class SystemUtil{
	public static boolean isAdmin(String userId){
		return userId.toLowerCase()=="admin";
	}
	public static void main(String[] args){
		System.out.println(isAdmin("Admin"));
	}
}

解析：
toLowerCase()方法的功能是：
	将String字符中的字母全变为小写，而非字母的保持不变。
	例如：toLowerCase（“Hannah_666”）的结果为“hannah_666”

3、阅读如下代码。 请问，对语句行 test.hello(). 描述正确的有（A）

class Test {
    public static void hello() {
        System.out.println("hello");
    }
}
public class MyApplication {
    public static void main(String[] args) {
        Test test=null;
        test.hello();
    }
}

A、能编译通过，并正确运行
B、因为使用了未初始化的变量，所以不能编译通过
C、以错误的方式访问了静态方法
D、能编译通过，但因变量为null，不能正常运行

解析：
因为Test类的hello方法是静态的，所以是属于类的，
当实例化该类的时候，静态会被优先加载而且只加载一次；

并且不受实例化new Test();语句影响，只要是使用到了Test类，都会加载静态hello方法！

另外，在其他类的静态方法中也是可以调用公开的静态方法，
此题hello方法是使用public修饰的所以在MyApplication中调用hello也可以。

总结：
在Test test=null;中会加载静态方法，所以test数据中包含Test类的静态初始化数据，
但是test并不能调用该类的非静态数据。

4. 在使用super和this关键字时，以下描述正确的是（A）

A 在子类构造方法中使用super（）显示调用父类的构造方法，super（）必须写在子类构造方法的第一行，否则编译不通过
B super（）和this（）不一定要放在构造方法内第一行
C this（）和super（）可以同时出现在一个构造函数中
D this（）和super（）可以在static环境中使用，包括static方法和static语句块

解析：
1. super()，this()和super，this关键字不是一个概念，
		前者是在构造器之间相互调用的语法，后者是代之父类或者本类的对象。
2. 每个构造器默认的第一行都是super()，但是有的时候直接父类的没有无参构造，
	那么就必须在子类构造的第一行显式的声明要调用哪个构造器。
3. this()和super()都必须出现在构造器的第一行，所以两者不可能出现在同一个构造器中。
4. this和super都不能出现在静态方法、静态块中。

为什么要放置在第一行？
1、super()防止子类后面调用父类属性，在第一行初始化父类；
2、this()其自带调用super(),出现第一行，保证父类初始化的唯一性，不然会多次重复初始化

5、如下代码的结果是？（BaseBase）

class Base {
	Base() {
		System.out.print("Base");
	}
}
public class Alpha extends Base {
	public static void main( String[] args ) {
		new Alpha();
		//调用父类无参的构造方法
		new Base();
	}
}

解析：
Alpha作为子类继承了父类Base,当子类实例化对象前会先调用父类的构造方法产生父类对象，
由两条new语句分别调用父类构造方法一次，所以输出 BaseBase。

6、如下代码的输出结果是什么？（编译错误）

public class Test {
	public int aMethod(){
		static int i = 0;
		i++;
		return i;
	}
	public static void main(String args[]){
		Test test = new Test();
		test.aMethod();
		int j = test.aMethod();
		System.out.println(j);
	}
}

解析：
从第三行语句开始就错了。
静态变量又称为“类变量”，始终跟类联系在一起，只能定义在类主体里，不能定义在方法中，
即便是静态方法也不行！！
static的任何都是先于类而加载的。

7、下列哪种描述是正确的？（D）

A abstract修饰符可修饰字段、方法和类
B 抽象方法的body部分必须用一对大括号{ }包住
C 声明抽象方法，大括号可有可无
D 声明抽象方法不可写出大括号

解析：
抽象方法不能拥有方法体，即不能写出代表代码块的{}大括号。
A ~ 不能修饰字段，可以有抽象类和抽象方法
B ~ 抽象方法不能有body部分，只能在子类中覆写
C ~ 声明时大括号绝对不能有，覆写时要补全方法体。

8、下列说法正确的是（C）

A class中的constructor不可省略
B constructor必须与class同名，但方法不能与class同名
C constructor在一个对象被new 时执行
D 一个class只能定义一个construct

解析：
A ~ 可以省略，系统默认提供无参构造器
B ~ 构造器支持重载，构造方法就是要与主类同名，且在子类中还要重载（类名相同但参数列表不同）

9、选项中哪一行代码可以替换 //add code here 而不产生编译错误（A）

public abstract class MyClass {
	public int constInt = 5;
	//add code here
	public void method() {
	}
}

A public abstract void method(int a);
B consInt=constInt+5;
C public int method();
D public abstract void anotherMethod()

解析：
A：抽象类可以包含抽象方法
B：类中定义成员和方法，不能直接进行运算，可以写在代码块{}或者静态代码块中static{}中
C: 与第四行想要构成重载，二者区别是返回类型，但是返回类型不能作为重载的依据
D: 该方法使用abstract修饰，是抽象方法，
	但是他有方法体(带有{}的就是方法体，即使里面是空的)，就不能作为抽象方法

10、java 中哪个关键字可以对对象加互斥锁？（B）

A transient
B synchronized
C serialize
D static

解析 ：
1、synchronized关键字  : 用来给对象和方法或者代码块加锁，
	当它锁定一个方法或者一个代码块的时候，同一时刻最多只有一个线程执行这个段代码。

2、volatile：用来确保将变量的跟新操作通知到其他线程，
	当把变量声明为volatile类型后，编译器与运行时都会注意到这个变量是共享的，
		因此不会将该变量上的操作与其他内存操作一起重排序。
		然而，在访问volatile变量时不会执行加锁操作，因此也就不会使执行线程阻塞，
		因此volatile变量是一种比 synchronized关键字更轻量级的同步机制。

3、serialize：Java 对象序列化为二进制文件。

4、static关键字： static关键字可以修饰变量，方法，静态代码块。
                          静态变量：
                          			① 由static修饰的变量称为静态变量
                          			② 静态变量属于类，而不属于某个对象
                          			③ 静态变量它的副本只有一个(静态变量在类中只加载一)
                         静态方法：
                         		① 在静态方法中只能调用静态变量和静态方法
                         		② 在非静态方法中，可以调用静态方法或者变量。
                         		③在静态方法中不能使用this和super关键字。
                        静态代码块：
                        		用来给静态成员变量初始化