选择题
1.在使用super和this关键字时，在子类构造方法中使用super()显示调用父类的构造方法，super()必须写在子类构造方法的第一行，否则编译不通过.
解析：1）调用super()必须写在子类构造方法的第一行，否则编译不通过。每个子类构造方法的第一条语句，都是隐含地调用super()，如果父类没有这种形式的构造函数，那么在编译的时候就会报错。
2）super()和this()类似,区别是，super从子类中调用父类的构造方法，this()在同一类内调用其它方法。
3）super()和this()均需放在构造方法内第一行。
4）尽管可以用this调用一个构造器，但却不能调用两个。
5）this和super不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造函数必然也会有super语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也不会通过。
6）this()和super()都指的是对象，所以，均不可以在static环境中使用。包括：static变量,static方法，static语句块。
7）从本质上讲，this是一个指向本对象的指针, 然而super是一个Java关键字。
2.已知如下类定义：
class Base {
public Base (){
//...
}
public Base ( int m ){
//...
}
public void fun( int n ){
//...
}
}
public class Child extends Base{
// member methods
}
如下哪句可以正确地加入子类中？（D）
A。private void fun( int n ){ //…}
B。void fun ( int n ){ //… }
C。protected void fun ( int n ) { //… }
D。public void fun ( int n ) { //… }
解析：方法的重写（override）两同两小一大原则：
方法名相同，参数类型相同
子类返回类型小于等于父类方法返回类型，
子类抛出异常小于等于父类方法抛出异常，
子类访问权限大于等于父类方法访问权限。
3./…/中可以嵌套//注释，也能嵌套/…/注释。（错）
4.假设有以下代码String s = “hello”；String t = “hello”；char c [ ] = {‘h’,‘e’,‘l’,‘l’,‘o’}；下列选项中返回false的语句是？（B）
A。s.equals (t)；
B。t.equals ©；
C。s== t；
D。t.equals (new String (“hello”))；
解析：首先 == 与equals是有明显区别的。
== 强调栈中的比较，可以理解为地址比较
equals强调对象的内容比较
String s=“hello”；会在栈中生成hello字符串，并存入字符串常量池中。
String t=“hello” ；创建时，会在字符串常量池中寻找，当找到需要的hello时，不进行字符串的创建，引用已有的。 所以，s== t返回true，s.equals(t)也是true。
char c[]={‘h’,‘e’,‘l’,‘l’,‘o’}; c==s这个是不存在的，==两边类型不同
t.equals©这个语句在anObject instanceof String这步判断不会通过，也就是cha[] 压根不能与String相比较，类型不是相同的。返回false
5.阅读下列程序，选择哪一个是正确的输出结果（C）
class HelloA{
public HelloA()
{
System.out.println("I’m A class ");
}
static
{
System.out.println("static A");
}
}
public class HelloB extends HelloA{
public HelloB()
{
System.out.println("I’m B class");
}
static{
System.out.println("static B");
}
public static void main (String[] args){
new HelloB();
}
}
A。static A I’m A class static B I’m B class
B。I’m A class I’m B class static A static B
C。static A static B I’m A class I’m B class
D。I’m A class static A I’m B class static B
解析： 类的初始化顺序是： 1、初始化父类中的静态成员变量和静态代码块。 2、初始化子类中的静态成员变量和静态代码块。 3、初始化父类中的普通成员变量和代码块，在执行父类中的构造方法。 4、初始化子类中的普通成员变量和代码块，在执行子类中的构造方法。
6.关于以下程序代码的说明正确的是?
1. public class HasStatic{
2. private static int x=100;
3. public static void main(String args[]){
4. HasStatic hs1=new HasStatic();
5. hs1.x++;
6. HasStatic hs2=new HasStatic();
7. hs2.x++;
8. hs1=new HasStatic();
9. hs1.x++;
10. HasStatic.x--;
11. System.out.println("x="+x);
12. }
13. }
A。程序通过编译，输出结果为：x=103
B。10行不能通过编译，因为x是私有静态变量
C。5行不能通过编译，因为引用了私有静态变量
D。程序通过编译，输出结果为：x=102
解析：main是HasStatic的静态方法，在其内部可直接访问静态变量，不存在因为私有变量不能通过编译的问题；如果在其他类中，包括HasStatic的派生类中，均不能访问其私有静态变量
7.枚举（enum）属于原始数据类型（primitive type）。（错×）
解析：在Java中，变量有两种类型，一种是原始类型，一种是引用类型。
原始类型一共有8种，它们分别是char,boolean,byte,short,int,long,float,double。在Java API中，有它们对应的包装类，分别是(首字母大写)Character,Boolean,Byte,Short,Integer,Long,Float,Double(char,int的变化稍微大点)。
JAVA JVM对于不同的原始类型会分配不同的存储空间，具体分配如下：
byte : 1个字节 8位
最大值: 127 (有符号)
short : 2个字节 16位 32767
int : 4个字节 32位 2147483647
long: 8个字节 64位 9223372036854775807
float: 4个字节 32位 3.4028235E38
double:8个字节 64位 1.7976931348623157E308
枚举（enum）类型是Java 5新增的特性，它是一种新的类型，允许用常量来表示特定的数据片断，而且全部都以类型安全的形式来表示，是特殊的类，可以拥有成员变量和方法。
8.下列关于异常处理的描述中，错误的是( D )。
A。程序运行时异常由Java虚拟机自动进行处理
B。使用try-catch-finally语句捕获异常
C。可使用throw语句抛出异常
D。捕获到的异常只能在当前方法中处理，不能在其他方法中处理
解析：运行时异常java虚拟机会自行处理，只有当是检查时异常java会强制性抛出异常，对异常进行处理。
-
运行型异常由JVM自行处理，程序员不需要管。
检查型异常由编译器检查，需要程序员手动捕获处理。 -
捕获到的异常可以选择在当前方法中处理，也可以在调用它的上一级方法中抛出。
-
编译时异常必须显示处理，运行时异常交给虚拟机。
运行时异常可以不处理。当出现这样的异常时，总是由虚拟机接管。比如我们从来没有人去处理过Null Pointer Exception异常，它就是运行时异常，并且这种异常还是最常见的异常之一。出现运行时异常后，系统会把异常一直往上层抛，一直遇到处理代码。如果没有处理块，到最上层，如果是多线程就由Thread.run()抛出，如果是单线程就被main()抛出。抛出之后，如果是线程，这个线程也就退出了。如果是主程序抛出的异常，整个程序也就退出了。运行时异常是Exception的子类，也有一般异常的特点，是可以被Catch块处理的。只不过往往不对它处理罢了。也就是说，如果不对运行时异常进行处理，那么出现运行时异常之后，要么是线程中止，要么是主程序终止。
9.以下代码执行的结果显示是多少（ ）？public class Demo { class Super{ int flag=1;
Super(){
test();
} void test(){
System.out.println(“Super.test() flag=”+flag);
}
} class Sub extends Super{
Sub(int i){ flag=i;
System.out.println(“Sub.Sub()flag=”+flag);
} void test(){
System.out.println(“Sub.test()flag=”+flag);
}
} public static void main(String[] args) { new Demo().new Sub(5);
}
}
A。 Sub.test() flag=1
Sub.Sub() flag=5
B。 Sub.Sub() flag=5
Sub.test() flag=5
C。 Sub.test() flag=0
Sub.Sub() flag=5
D。 Super.test() flag=1
Sub.Sub() flag=5
解析：在继承中代码的执行顺序为：1.父类静态对象，父类静态代码块
2.子类静态对象，子类静态代码块
3.父类非静态对象，父类非静态代码块
4.父类构造函数
5.子类非静态对象，子类非静态代码块
6.子类构造函数
对于本题来说：在只想new Sub(5)的时候，父类先初始化了 int flag = 1，然后执行父类的构造函数Super（），父类构造函数中执行的test（）方法，因子类是重写了test（）方法的，因此父类构造函数中的test（）方法实际执行的是子类的test（）方法，所以输出为Sub.test() flag=1，接着执行子类构造函数Sub(5) 将flag赋值为5，因此输出结果Sub.Sub() flag=5。最终选择了A。
10.容器panel缺省使用的布局编辑策略是( B)
A。Border Layout
B。Flow Layout
C。GridLayout
D。Card Layout
解析：系统默认的是流试的FlowLayout的布局管理器