Java笔试题库之选题题篇【1-70题】

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<Short> s=new HashSet<Short>();

　　　　　　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.下列代码哪行会出错: 

1) 　　public void modify() {

2) 　　　　int I, j, k;

3) 　　　　I = 100;

4) 　　　　while ( I > 0 ) {

5) 　　　　　　j = I * 2;

6) 　　　　　　System.out.println (” The value of j is ” + j );

7) 　　　　　　k = k + 1;

8) 　　　　　　I - -;

9) 　　　　}

10) 　　}

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{

6)

7) 　　 }

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;

5.

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．在类方法中可以通过实例化对象调用类中的实例成员。

原文链接:https://www.cnblogs.com/wgc-blog/p/10479606.html
如有疑问请与原作者联系

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有