1.下面中哪两个可以在A的子类中使用：（ ）
class A {
protected int method1 (int a, int b) {
return 0;
}
}
A. public int method 1 (int a, int b) { return 0; }
B. private int method1 (int a, int b) { return 0; }
C. private int method1 (int a, long b) { return 0; }
D. public short method1 (int a, int b) { return 0; }
解答：AC
A，符合子类重写父类方法的规则
B，子类重写父类的方法，访问权限不能降低
C，属于重载
D，子类重写父类的方法 返回值类型要相同或是父类方法返回值类型的子类
2.抽象方法可以被static修饰嘛？
A True
B False
解答：B
抽象方法可以在子类中被重写，但是静态方法不能在子类中被重写，静态方法和静态属性与对象是无关的，只与类有关，这与abstract是矛盾的，所以abstract是不能被修饰为static，否则就失去了abstract的意义了
3.以下程序的执行结果是什么？
class Base{
void test() {
System.out.println(“Base.test()”);
}
}
public class Child extends Base {
void test() {
System.out.println(“Child.test()”);
}
public static void main(String[] a) {
Child anObj = new Child();
Base baseObj = (Base)anObj;
baseObj.test();
}
}
A Child.test() Base.test()
B Base.test() Child.test()
C Base.test()
D Child.test()
解答：D
测试代码相当于：Base baseObj = new Child();父类的引用指向子类的实例，子类又重写了父类的test方法，因此调用子类的test方法。
4.以下程序的执行结果是什么
class Base{
static void test() {
System.out.println(“Base.test()”);
}
}
public class Child extends Base {
void test() {
System.out.println(“Child.test()”);
Base.test(); //Call the parent method
}
static public void main(String[] a) {
new Child().test();
}
}
A Child.test() Base.test()
B Child.test() Child.test()
C 编译报错.
D 运行报错.
解答：C
静态方法不能在子类中被重写
5.以下程序的执行结果是什么
public class Base{
private void test() {
System.out.println(6 + 6 + “(Result)”+6+6);
}
static public void main(String[] a) {
new Base().test();
}
}
A 66(Result)66
B 12(Result)12
C 66(Result)12
D 12(Result)66
解答：D
字符串与基本数据类型链接的问题,如果第一个是字符串那么后续就都按字符串处理，比如上边例子要是System.out.println(“(Result)”+6 + 6 );那么结果就是(Result)66，如果第一个和第二个。。。第n个都是基本数据第n+1是字符串类型，那么前n个都按加法计算出结果在与字符串连接
6.以下程序的执行结果是什么；’ ?’ 是空格的意思.
public class Base{
private void test() {
String aStr = “?One?”;
String bStr = aStr;
aStr.toUpperCase();
aStr.trim();
System.out.println(“[" + aStr + "," + bStr + "]“);
}
static public void main(String[] a) {
new Base().test();
}
}
A [ONE,?One?]
B [?One?,One]
C [ONE,One]
D [ONE,ONE]
E [?One?,?One?]
解答：E
通过String bStr = aStr;这句代码使bStr和aStr指向同一个地址空间，所以最后aStr和bStr的结果应该是一样，并且aStr在调用了方法之后，并没有将结果重洗赋值给aStr（即aStr=aStr.toUpperCase();）所以aStr调用了方法之后其原本的值并没有被改变
7.下面关于变量及其范围的陈述哪些是不正确的（ ）：
A．实例变量是类的成员变量
B．实例变量用关键字static声明
C．在方法中定义的局部变量在该方法被执行时创建
D．局部变量在使用前必须被初始化
解答：BC
由static修饰的变量称为类变量或是静态变量；方法加载的时候创建局部变量
8.下列关于修饰符混用的说法，错误的是（ ）：
A．abstract不能与final并列修饰同一个类
B．abstract类中可以有private的成员
C．abstract方法必须在abstract类中
D．static方法中能处理非static的属性
解答 D
:静态方法中不能引用非静态的成员
9.执行完以下代码int[ ] x = new int[25]；后，以下哪项说明是正确的（ ）：
A、 x[24]为0
B、 x[24]未定义
C、 x[25]为0
D、 x[0]为空
解答：A
x属于引用类型的int数组，数组定义以后，该引用类型的每一个成员是int类型，默认值都为：0；并且数组是以0为索引开始算，虽然其长度为25，但其最大下标只有25-1
10.编译运行以下程序后，关于输出结果的说明正确的是 （ ）：
public class Conditional{
public static void main(String args[ ]){
int x=4;
System.out.println(“value is “+ ((x>4) ? 99.9 :9));
}
}
A、 输出结果为：value is 99.99
B、 输出结果为：value is 9
C、 输出结果为：value is 9.0
D、 编译错误
解答：C
三目运算符中：第二个表达式和第三个表达式中如果都为基本数据类型，整个表达式的运算结果由容量高的决定。99.9是double类型 而9是int类型，double容量高。
11.关于以下application的说明，正确的是（ ）：
1. class StaticStuff{
2. static int x=10；
3. static { x+=5；}
4. public static void main（String args[ ]）{
5. System.out.println(“x=” + x);
6. }
7. static { x/=3;}
8. }
A、 3行与7行不能通过编译，因为缺少方法名和返回类型
B、 7行不能通过编译，因为只能有一个静态初始化器
C、 编译通过，执行结果为：x=5
D、编译通过，执行结果为：x=3
解答：C
静态代码块是类加载的时候就会被执行到的，静态代码块的执行顺序是按照在类中出现的先后顺序执行。
12.关于以下程序代码的说明正确的是（ ）：
1． 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、5行不能通过编译，因为引用了私有静态变量
B、10行不能通过编译，因为x是私有静态变量
C、程序通过编译，输出结果为：x=101
D、程序通过编译，输出结果为：x=102
E、程序通过编译，输出结果为：x=103
解答：D
静态变量是所有对象所共享的，所以上述代码中的几个对象操作是同一静态变量x， 静态变量可以通过类名调用。
13.下列说法正确的有（）
A． class中的constructor不可省略
B． constructor必须与class同名，但方法不能与class同名
C． constructor在一个对象被new时执行
D．一个class只能定义一个constructor
解答：C
构造方法的作用是在实例化对象的时候给数据成员进行初始化
A．类中如果没有显示的给出构造方法，系统会提供一个无参构造方法
B．构造方法与类同名，类中可以有和类名相同的方法
D．构造方法可以重载
14.下列哪种说法是正确的（）
A．实例方法可直接调用超类的实例方法
B．实例方法可直接调用超类的类方法
C．实例方法可直接调用其他类的实例方法
D．实例方法可直接调用本类的类方法
解答：D
A. 实例方法不可直接调用超类的私有实例方法
B. 实例方法不可直接调用超类的私有的类方法
C．要看访问权限
15.下列哪一种叙述是正确的（ ）
A． abstract修饰符可修饰字段、方法和类
B． 抽象方法的body（方法实体）部分必须用一对大括号{ }包住
C． 声明抽象方法，大括号可有可无
D． 声明抽象方法不可写出大括号
解答：D
abstract可以修饰方法和类，不能修饰属性。抽象方法没有方法体，即没有大括号{}
16.下面代码的执行结果是？
import java.util.*;
public class ShortSet{
public static void main(String args[]){
Set
for(Short i=0;i<100;i++){
s.add(i);
s.remove(i-1);
}
System.out.println(s.size());
}
}
A.1
B.100
C.Throws Exception
D.None of the Above
解答：B
i是Short类型， i-1是int类型,其包装类为Integer，所以s.remove(i-1)不能移除Set集合中Short类型对象；只有将（i-1）强转为Short类型的时候，才能移除Set集合中的对象
17.链表具有的特点是：
A、不必事先估计存储空间
B、可随机访问任一元素
C、插入删除不需要移动元素
D、所需空间与线性表长度成正比
解答：ACD
A.采用动态存储分配，不会造成内存浪费和溢出。
B. 不能随机访问，查找时要从头指针开始遍历
C. 插入、删除时，只要找到对应前驱结点，修改指针即可，无需移动元素
D. 需要用额外空间存储线性表的关系，存储密度小
18.Java语言中，String类的IndexOf()方法返回的类型是？
A、Int16 B、Integer C、int D、long
解答：C
indexOf方法的声明为：public int indexOf(int ch)在此对象表示的字符序列中第一次出现该字符的索引；如果未出现该字符，则返回 -1。
19.以下关于面向对象概念的描述中，不正确的一项是（）。
A.在现实生活中，对象是指客观世界的实体
B.程序中的对象就是现实生活中的对象
C.在程序中，对象是通过一种抽象数据类型来描述的，这种抽象数据类型称为类（class）
D.在程序中，对象是一组变量和相关方法的集合
解答：B
面向过程强调的是每一个功能的具体实现步骤，面向对象强调的是对象调用功能
20..执行下列代码后,哪个结论是正确的
String[] s=new String[10];
A． s[9] 为 null;
B． s[10] 为 “”;
C． s[0] 为 未定义
D． s.length 为10
解答：AD
s是引用类型，s中的每一个成员都是引用类型，即String类型，String类型默认的值为null
21.属性的可见性有。(不定项选择)
A.公有的
B.私有的
C.私有保护的
D.保护的
E.默认的
解答：ABDE
属性的可见性有四种：公有的（public） 保护的（protected） 默认的 私有的（private）
22..在字符串前面加上_____符号，则字符串中的转义字符将不被处理。
A @
B \
C #
D %
解答：B
在java中“\”表示转译符，改变了后面字符的本来意思；\r：回车；\n：换行（new line）；\t：相当于tab键（叫制表符太生涩）；\\：表示\；\'：表示'；\"：表示"
23.下列代码哪行会出错:
public void modify() {
int I, j, k;
I = 100;
while ( I > 0 ) {
j = I * 2;
System.out.println (” The value of j is ” + j );
k = k + 1;
I - -;
}
}
A. 4
B. 6
C. 7
D. 8
解答：C
k没有初始化就使用了
24.对记录序列{314，298，508，123，486，145}按从小到大的顺序进行插入排序，经过两趟排序后的结果为：
A {314，298，508，123，145，486}
B {298，314，508，123，486，145}
C {298，123，314，508，486，145}
D {123、298，314，508，486，145}
解答：B
插入排序算法：（）
public static void injectionSort(int[] number) {
// 第一个元素作为一部分，对后面的部分进行循环
for (int j = 1; j < number.length; j++) {
int tmp = number[ j ];
int i = j – 1;
while (tmp < number[ i ]) {
number[i + 1] = number[ i ];
i - -;
if (i == -1)
break;
}
number[i + 1] = tmp;
}
}
25.栈是一种。
A 存取受限的线性结构
B 存取不受限的线性结构
C 存取受限的非线性结构
D 存取不受限的非线性结构
解答：A
栈（stack）在计算机科学中是限定仅在表尾进行插入或删除操作的线性表。
26.下列哪些语句关于内存回收的说明是正确的。
A 程序员必须创建一个线程来释放内存
B 内存回收程序负责释放无用内存
C 内存回收程序允许程序员直接释放内存
D 内存回收程序可以在指定的时间释放内存对象
解答：B
垃圾收集器在一个Java程序中的执行是自动的，不能强制执行，即使程序员能明确地判断出有一块内存已经无用了，是应该回收的，程序员也不能强制垃圾收集器回收该内存块。程序员唯一能做的就是通过调用System. gc 方法来”建议”执行垃圾收集器，但其是否可以执行，什么时候执行却都是不可知的。
27.要实现java.long.Runnable接口，必须实现下列哪个方法？
A. void run()
B. public void run()
C. public void start()
D. void run(int priority)
E. public void run(int priority)
F. public void start(int priority)
解答：B
实现Runnable接口，接口中有一个抽象方法run，实现类中实现该方法。
28 下列程序的结果是什么？
1 public static void main(String[] args) {
2 Object obj = new Object() {
3 public int hashCode() {
4 return 42;
5 }
6 };
7 System.out.println(obj.hashCode());
8 }
A. 42
B.在运行时抛出异常
C. 编译失败，原因是第2行出现错误
D. 编译失败，原因是第3出现错误
E. 编译失败，原因是第7行出现错误.
解答：A
匿名内部类重写了hashCode方法。
29 java中的两个保留字是什么
A. const
B. import
C. doto
D. implements
解答：AC
const用于修改字段或局部变量的声明。它指定字段或局部变量的值是常数，不能被修改
goto指定跳转到标签，找到标签后，程序将处理从下一行开始的命令
30. 在一个类中重写了hashCode和equals两个方法，那么对于同一个类的两个实例，下列说法正确的是？
A. 如果hashCode值相同，equsal不同，则这两个对象相同
B. 如果hashCode值相同，equals相同，则这两个对象相同
C. 如果hashCode不同，equals相同，则这两个对象相同
D. 如果hashCode值相同，则这两个对象有可能相同
解答：BD
先通过 hashcode来判断某个对象是否存放某个桶里，但这个桶里可能有很多对象，那么我们就需要再通过 equals 来在这个桶里找到我们要的对象。
31. java中char的取值范围是多少?
A. 0 ~32767
B. 0 ~65535
C. –65535~65535
D. –128 ~127
解答：B
在Java中，char是一个无符号16位类型，取值范围为0到65535。
32. 下列程序运行结果是什么？
public class Test {
private static float[] f = new float[2];
public static void main(String args[]) {
System.out.println(“f[0] = “ + f[0]);
}
}
A. f[0] = 0
B. f[0] = 0.0
C. 编译时报错
D. 运行时报错
解答：B
f属于引用类型的float数组，数组定义以后，该引用类型的每一个成员是float类型，默认值都为：0.0
33. 下列程序的运行结果是什么？
public class Test {
public static void main(String[] args) {
String str = NULL;
System.out.println(str);
}
}
A. NULL
B. 编译时报错
C. ""
D.运行时报错
解答：B
null应该小写
34、下列程序执行结果是什么？
public class Text{
public static void main(String[] args){
int a=10,b=4,c=20,d=6;
System.out.println(a++*b+c*--d);
}
}
A、144
B、164
C、140
D、160
解答：C
在java中执行加减乘除基本运算时，已就遵循先乘除后加减的原则，而++a与a++的区别在于，++a是先自增后在参与运算，a++是先参与运算之后在自增，所以最终答案是10*4+20*5=140
35、下列哪两个选项不能直接导致线程停止？
A. 跳出同步代码块
B. 调用wait方法
C. 调用notify方法
D. 调用读取流的方法
E. 设置线程的优先权
解答：AC
stop方法.这个方法将终止所有未结束的方法，包括run方法。当一个线程停止时候，他会立即释放 所有他锁住对象上的锁。这会导致对象处于不一致的状态。 当线程想终止另一个线程的时候，它无法知道何时调用stop是安全的，何时会导致对象被破坏。所以这个方法被弃用了。你应该中断一个线程而不是停止他。被中断的线程会在安全的时候停止。
A、如果一个线程想进入一个已经被另外一个线程占用得同步代码块，这个线程会停止，但是这里说的是跳出
B、他能使当前线程停止，等待别人调用notify方法
C、放另外一个调用了wait方法得线程继续执行，自己也可以继续执行
D、这是典型的阻塞方法，线程等待知道确实有东西可读得时候才会去读
E、因为优先级改变了，JVM要重新选择优先级高得先执行，所以会短暂停止
36、 关于默认构造函数的创建，下列说法那些正确
A. 默认构造函数可以初始化方法变量
B. 构造方法默认调用超类的无参构造方法
C. 默认构造方法会去初始化成员变量
D. 如果没有无参构造函数，但有其他构造函数，程序会自动创建默认的构造函数
E. 只有在该类没有其他构造函数的时候，程序才会自动创建默认的构造函数
解答：BCE
构造方法的作用是实例化对象的时候给数据成员初始化，如果类中没有显示的提供构造方法，系统会提供默认的无参构造方法，如果有了其它构造方法，默认的构造方法不再提供。
37、 在下列程序中声明一个内部内，以下选择中，哪些最合适？
public class OuterClass {
private double d1 = 1.0;
//在这里声明
}
A. static class InnerOne { public double methoda() {return d1;} }
B. static class InnerOne { static double methoda() {return d1;} }
C. private class InnerOne { public double methoda() {return d1;} }
D. protected class InnerOne { static double methoda() {return d1;} }
E. public abstract class InnerOne { public abstract double methoda(); }
解答：CE
AB.内部类可以声明为static的，但此时就不能再使用外层封装类的非static的成员变量；
D.非static的内部类中的成员不能声明为static的，只有在顶层类或static的内部类中才可声明static成员
38、 下列方法中，哪些方法在子类中不能重写?
A. final void methoda() {}
B. void methoda() {}
C. static void methoda() {}
D. static final void methoda() {}
解答：ACD
final修饰方法，在子类中不能被重写。被static修饰的方法在子父类中不算是重写，其底层是把父类的同名方法隐藏了
39、下列程序的运行结果是什么:
public class Test {
public static void main (String args[]) {
class Foo {
public int i = 3;
}
Object o = (Object) new Foo();
Foo foo = (Foo)o;
System.out.println(foo.i);
}
}
A. 编译失败
B. 编译成功，并且会输出打印“3”
C. 编译成功，但会在第6行抛出ClassCastException异常
D. 编译成功，但会在第7行抛出ClassCastException异常
解答：B
局部内部类的使用
40、 下列程序的运行结果是什么:
public class Test {
public static void main (String [] args) {
String foo = “blue”;
String bar = foo;
foo = “green”;
System.out.println(bar);
}
}
A. 运行时异常
B. 编译时异常
C. 输出结果为“null”
D. 输出结果为 “blue”
E. 输出结果为 “green”
解答：D
采用String foo = “blue”定义方式定义的字符串放在字符串池中，通过String bar = foo;他们指向了同一地址空间，就是同一个池子，当执行foo = “green”; foo指向新的地址空间。
41、下面哪个选项中整型变量foo的值最接近但是不大于double型变量bar的值？
A. int foo = (int) Math.max(bar);
B. int foo = (int) Math.min(bar);
C. int foo = (int) Math.abs(bar);
D. int foo = (int) Math.ceil(bar);
E. int foo = (int) Math.floor(bar);
F. int foo = (int) Math.round(bar);
解答：E
max方法是取最大值
min方法是取最小值
abs方法是取bar的绝对值，
ceil方法返回最小的（最接近负无穷大）double 值，该值大于等于参数，并等于某个整数。
floor方法返回最大的（最接近正无穷大）double 值，该值小于等于参数，并等于某个整数。
round方法 返回最接近参数的 long。
42、 下列程序的运行结果是什么:
1. package foo;
2. import java.util.Vector;
3. private class MyVector extends Vector {
4. int i = 1;
5. public MyVector() {
6. i = 2;
7. }
8. }
9. public class MyNewVector extends MyVector {
10. public MyNewVector () {
11. i = 4;
12. }
13. public static void main (String args []) {
14. MyVector v = new MyNewVector();
15. }
16. }
A. 编译成果
B. 在第3行编译失败
C. 在第6行编译失败
D. 在第9行编译失败
E. 在第14行编译失败
解答：B
类MyVector不能是私有的
43、下列程序执行结果是什么？
public class Text{
public static void main(String[] args){
int i=12;
System.out.println(i+=i-=i*=i);
}
}
A、程序无法编译
B、100
C、0
D、-120
解答：D
在java中执行加减乘除基本运算时，已就遵循先乘除后加减的原则，而i+=i相当于i=i+i；
本题我们先将i+=i-+i*=i编号 => i1+=i2-=i3*=i4;在计算之前先明白i1=i2=i3=i4=i=12;先计算i3=i*i=144,;再计算i1+=i2即为i1=i1+i2=24，此时i1=i2=24;最后计算i2-=i3即为i2=i2-i3=-120;
44、 下列选项中，哪些选项与第2行相等:
1. public interface Foo{
2. int k = 4;
3. }
A. final int k = 4;
B. Public int k = 4;
C. static int k = 4;
D. Private int k = 4;
E. Abstract int k = 4;
F. Volatile int k = 4;
G. Transient int k = 4;
H. protected int k = 4;
解答：AB
static：修饰的静态变量
final 修饰的是常量
abstract不能修饰变量
Volatile修饰的成员变量在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。而且，当成员变量发生变化时，强迫线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
Transient：对不需序列化的类的域使用transient关键字,以减少序列化的数据量。
int k=4相当于public static final int k=4; 在接口中可以不写static final
45、 下列代码的执行结果是什么:
public class foo {
static String s;
public static void main (String[]args) {
System.out.println (“s=” + s);
}
}
A. 代码编译成功并输出“s=”
B. 代码编译成功并输出“s=null”
C. 因为变量s没有初始化，所以代码编译失败
D. 代码编译成功，但在调用toString的时候抛出NullPointerException异常
解答：B
String为引用数据类型，引用类型数据成员的默认值为null
46、下列创建数组实例正确的是?
A. int[] ia = new int [15];
B. float fa = new float [20];
C. char[] ca = “Some String”;
D. Object oa = new float[20];
E. Int ia [][] = (4, 5, 6) (1, 2, 3)
解答：AD
任何类的父类都是Object，数组也数据引用类型，Object oa = new float[20];这种写法相当于父类的用指向之类的实例。
47、下列代码中，在第四行 /X/ 可以插入那些选项进行编译？
public class ExceptionTest {
class TestException extends Exception {}
public void runTest () throws TestException {}
public void test () /X/ {
runTest ();
}
}
A. throws Exception
B. Catch (Exception e).
C. Throws RuntimeException.
D. Catch (TestException e).
E. No code is necessary.
解答：A
方法上使用throws抛出异常，Exception是异常类的超类。
48、下列代码的执行结果是什么:
public class SwitchTest {
public static void main (String []args) {
System.out.println (“value =” +switchIt(4));
}
public static int switchIt(int x) {
int j = 1;
switch (x) {
case 1:j++;
case 2: j++;
case 3: j++;
case 4: j++;
case 5: j++;
default:j++;
}
return j + x;
}
}
A. Value =3
B. Value =4
C. Value =5
D. Value =6
E. Value =7
F. Value =8
解答：F
由于case块没有break语句，那么从case 4：向下的代码都会执行。
49、下列选项中，那些是可以被throw抛出的?
A. Error
B. Event
C. Object
D. Exception
E. Throwable
F. RuntimeException
解答：ADEF
能够抛出的对象类型要是Throwable 或是Throwable的子类
50．在下面程序的第6行补充上下列哪个方法,会导致在编译过程中发生错误?
1) class Super{
2) public float getNum(){
3) return 3.0f;
4) }
}
5) pubhc class Sub extends Super{
}
A,public float getNum(){retun 4.0f;}
B.public void getNum(){}
C.public void getNum(double d){}
D.public double getNum(float d){ retun 4.0f ;}
解答：B
方法重写的问题。子类中有和父类的方法名相同，但是参数不同，不会出编译错误，认为是子类的特有的方法，但是如果子类中方法和父类的方法名，参数，访问权限，异常都相同，只有返回值类型不同会编译不通过。
51.下面关于import, class和package的声明顺序哪个正确？( )
A. package, import, class
B. class, import, package
C. import, package, class
D. package, class, import
解答：A
在java代码中，一个类从第一行到结尾，一般顺序是 本类地址（在哪个包下） 导了什么包 class声明
52.下面哪个是正确的？( )
A. String temp [] = new String {“a” “b” “c”};
B. String temp [] = {“a” “b” “c”}
C. String temp = {“a”, “b”, “c”}
D. String temp [] = {“a”, “b”, “c”}
解答：D
53.关于java.lang.String类，以下描述正确的一项是（ ）
A. String类是final类故不可以继承；
B. String类是final类故可以继承；
C. String类不是final类故不可以继承；
D. String类不是final类故可以继承；
解答：A
String类是自读字符串，被final修饰，在java中final修饰类的不能被继承
54.关于实例方法和类方法，以下描述正确的是：( )
A. 实例方法只能访问实例变量
B. 类方法既可以访问类变量，也可以访问实例变量
C. 类方法只能通过类名来调用
D. 实例方法只能通过对象来调用
解答：D
A 实例方法可以访问类变量
B 类方法只能访问类变量
C 类方法可以通过对象调用
55.接口是Java面向对象的实现机制之一，以下说法正确的是：( )
A. Java支持多继承，一个类可以实现多个接口；
B. Java只支持单继承，一个类可以实现多个接口；
C. Java只支持单继承，一个类只可以实现一个接口；
D. Java支持多继承，但一个类只可以实现一个接口。
解答：B
Java支持单重继承，一个类只能继承自另外的一个类，但是一个类可以实现多个接口。但是java可以多层继承
56.下列关于interface（接口）的说法正确的是：( )
A. interface中可以有private方法
B. interface中可以有final方法
C. interface中可以有function实现
D. interface可以继承其他interface
解答：D
A．接口中不可以有private的方法,接口不能被私有化
B．接口中不可以有final的方法 接口中的方法默认是 public abstract的
C．接口中的方法不可以有实现
57.已知A类被打包在packageA , B类被打包在packageB ，且B类被声明为public ，且有一个成员变量x被声明为protected控制方式 。C类也位于packageA包，且继承了B类 。则以下说话正确的是（ ）
A. A类的实例不能访问到B类的实例
B. A类的实例能够访问到B类一个实例的x成员
C. C类的实例可以访问到B类一个实例的x成员
D. C类的实例不能访问到B类的实例
解答：C
A、B包是public的，其他包能访问到
B、B包中的成员变量X被声明成protected的，只能本包内实例才能访问
C D、不同包子类的关系， 可以访问到父类B的protected成员
58.以下程序正确的输出是（ ）
package test;
public class FatherClass {
public FatherClass() {
System.out.println(“FatherClass Create”);
}
}
package test;
import test.FatherClass;
public class ChildClass extends FatherClass {
public ChildClass() {
System.out.println(“ChildClass Create”);
}
public static void main(String[] args) {
FatherClass fc = new FatherClass();
ChildClass cc = new ChildClass();
}
}
A.
FatherClass Create
FatherClass Create
ChildClass Create
B.
FatherClass Create
ChildClass Create
FatherClass Create
C.
ChildClass Create
ChildClass Create
FatherClass Create
D.
ChildClass Create
FatherClass Create
FatherClass Create
解答：A
实例化一个类的时候，就会去调用它的构造方法；在子类构造方法执行时，默认情况下第一句是super();来调用父类的构造方法
59.给定如下代码，下面哪个可以作为该类的构造函数 ( )
public class Test {
}
A. public void Test() {?}
B. public Test() {?}
C. public static Test() {?}
D. public static void Test() {?}
解答：B
构造方法：与类同名没有放回类型
60.题目:
1. public class test (
2. public static void main (String args[]) {
3. int i = 0xFFFFFFF1;
4. int j = ~i;
6. }
7. }
程序运行到第5行时,j的值为多少?( )
A. –15
B. 0
C. 1
D. 14
E. 在第三行的错误导致编译失败
解答：D
int i = 0xFFFFFFF1;相当于 int i=-15 “~”表示取反再减1；结果就为15-1=14
61.关于sleep()和wait()，以下描述错误的一项是（ ）
A. sleep是线程类（Thread）的静态方法，wait是Object类的方法；
B. sleep不释放对象锁，wait放弃对象锁；
C. sleep暂停线程、但监控状态仍然保持，结束后会自动恢复；
D. wait后进入等待锁定池，只有针对此对象发出notify方法后获得对象锁进入运行状态。
解答：D
sleep是线程类（Thread）的静态方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用sleep不会释放对象锁。
wait是Object类的方法，必须和synchronized关键字一起使用。对此对象调用wait方法导致本线程进入阻塞状态，，只有针对此对象发出notify方法（或notifyAll）后本线程才会解除阻塞，但只有重新占用互斥锁之后，本线程才会进入运行状态。
62.下面能让线程停止执行的有（多选）( )
A. sleep();
B. stop();
C. notify();
D. synchronized();
E. yield();
F. wait();
G. notifyAll();
解答：ABDEF
sleep：导致此线程暂停执行指定时间
stop: 这个方法将终止所有未结束的方法，包括run方法。
synchronized():对象锁
yield：当前正在被服务的线程可能觉得cpu的服务质量不够好，于是提前退出，这就是yield。
wait：当前正在被服务的线程需要睡一会，醒来后继续被服务
63.下面哪个可以改变容器的布局？( )
A. setLayout(aLayoutManager);
B. addLayout(aLayoutManager);
C. layout(aLayoutManager);
D. setLayoutManager(aLayoutManager);
解答：A
Java设置布局管理器setLayout()
64.在使用super和this关键字时，以下描述正确的是（）
A、super（）和this（）不一定要放在构造方法第一行
B、this（）和super（）可以同时出现在一个构造函数中
C、this（）和super（）可以在static环境中使用，包括static方法和static代码块
D、在子类构造方法中，使用super（）显示调用父类的构造方法，super（）必须写在子类构造方法的第一行，否则编译失败
解答：D
super（）是调用父类方法，this（）是调用子类方法，子类方法中，只能放在方法的第一行，并且，他们两不能同时出现在一个构造函数中，也不能调用被static修饰的方法和代码块
65.提供Java存取数据库能力的包是（）
A．java.sql
B．java.awt
C．java.lang
D．java.swing
解答：A
java.sql是JDBC的编程接口
java.awt和java.swing是做图像界面的类库
java.lang: Java 编程语言进行程序设计的基础类
66.不能用来修饰interface的有（）
A．private
B．public
C．protected
D．static
解答：ACD
修饰接口可以是public和默认
67.下列说法错误的有（）
A． 在类方法中可用this来调用本类的构造方法
B． 在类方法中调用本类的类方法时可直接调用
C． 在类方法中只能调用本类中的类方法
D． 在类方法中绝对不能调用实例方法
解答：ACD
A. 在类方法中，被static修饰的方法里不能用this，在其他没有被static修饰的类中可以使用this，但不能调本类的构造方法
C．在类方法中可以调用其它类中的静态类方法
D．在类方法中可以通过实例化对象调用实例方法
68.从下面四段（A，B，C，D）代码中选择出正确的代码段（）
A． abstract class Name {
private String name;
public abstract boolean isStupidName(String name) {}
}
B． public class Something {
void doSomething () {
private String s ="";
int l = s.length();
}
}
C． public class Something {
public static void main(String[] args) {
Other o = new Other();
new Something().addOne(o);
}
public void addOne(final Other o) {
o.i++;
}
}
class Other {
public int i;
}
D． public class Something {
public int addOne(final int x) {
return ++x; }
}
解答：C
A..抽象方法不能有方法体
B．方法中定义的是局部变量，不能用类成员变量修饰符private
D．final修饰为常量，常量的值不能被改变，所以不能作为参数变量
69.选择下面代码的运行结果：（）。
public class Test{
public void method(){
for(int i = 0; i < 3; i++){
System.out.print(i);
}
System.out.print(i);
}
}
A．122
B．123
C．编译错误
D．没有任何输出
解答：C
i变量的作用范围是整个for循环，第二次输出语句的i并没有被定义
70.请看如下代码
class Person {
private int a;
public int change(int m){
return m;
}
}
public class Teacher extends Person{
public int b;
public static void main(String arg[]){
Person p = new Person();
Teacher t = new Teacher();
int i;
// point x
}
}
下面哪些放在// point x?行是正确的？
A， i = m;
B， i = b;
C， i = p.a;
D， i = p.change(3);
E， i = t.b;
解答：DE
A.不同的作用域
B．静态方法中不能直接使用非静态成员变量
C．类外不能访问其它类私有的成员
D，E．在类方法中可以通过实例化对象调用类中的实例成员。
