笔试强训选择题错误总结

图文版md文件已上传

1..已知如下类定义：class Base { public Base (){ //... } public Base ( int m ){ //... } public void fun( int n ){ //... } } public class Child extends Base{ // member methods } 如下哪句可以正确地加入子类中？

A private void fun( int n ){ //...} B void fun ( int n ){ //... } C protected void fun ( int n ) { //... } D public void fun ( int n ) { //... } 正确答案：D

7.方法通常存储在进程中的哪一区（D） A 堆区 B 栈区 C 全局区 D 方法区 解析： 堆区放真正的数据，对象的属性信息；

栈区存放局部变量；

全局区放全局变量；

方法区存放方法；

另外，垃圾空间是指：没有任何栈内存指向的堆内存空间

假设 A 类有如下定义，设 a 是 A 类的一个实例，下列语句调用哪个是错误的？（C） public class A { public int i; static String s; void method1(){} static void method2(){} } 牛客出品-http://www.nowcoder.com A System.out.println(a.i); B a.method1(); C A.method1(); D A.method2();

因为 method1 没有被 static 修改所以不能直接通过类名来直接调用。

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

A 在子类构造方法中使用super（）显示调用父类的构造方法，super（）必须写在子类构造方法的第一行，否则编译不通过

B super（）和this（）不一定要放在构造方法内第一行

C this（）和super（）可以同时出现在一个构造函数中

D this（）和super（）可以在static环境中使用，包括static方法和static语句块

答案： A B ： super 和 this 必须放在构造方法的第一行 C ： super 和 this 不能同时出现，如果能那么谁放在第一行呢？ D ：this 和 super 是不能在 static 方法和 static 语句块的，因为被static 修饰是不需要对象的，而 super 和 this 是需要对象。

下列哪一种叙述是正确的（） A abstract修饰符可修饰字段、方法和类 B 抽象方法的body部分必须用一对大括号{ }包住 C 声明抽象方法，大括号可有可无 D 声明抽象方法不可写出大括号

答案： abstract是不能修饰字段的 , 抽象方法不需要大括号{} 包住的，写了就是具体实现. 所以答案就是我们的 D

下列说法正确的有：（C） A class中的constructor不可省略 B constructor必须与class同名，但方法不能与class同名 C constructor在一个对象被new 时执行 D 一个class只能定义一个constructor

这里 constructor 就是构造器的意思： A constructor 是可以省略的，编译器是会默认提供一个不带参数的 B 可以看到我们的构造方法就可以跟类同名，注意构造方法同样也是方法

C 正确 D 错误我们的构造方法可为多个构造重载

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

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

A : 可以 B ：这里对成员变量的赋值只能放在方法的内部

C ： method 不是抽象方法，所以不能省略{}

D : 这里我们被 abstract 修饰所以是一个抽象方法，这里就可以省略{}

所以答案 A

2.以下程序的输出结果为

class Base{ public Base(String s){ System.out.print("B"); } } public class Derived extends Base{ public Derived (String s) { System.out.print("D"); } public static void main(String[] args){ new Derived("C"); } } A : BD

B : DB

C : C

D : 编译错误

这里考的就是继承中的创建子类对象时会通过子类的构造方法先帮助父类进行构造，但题目中的父类拥有带一个参数的构造方法，所以此时就不会提供不带参数的构造方法，但因为我们的子类中没有通过super(s) 帮助父类进行构造所以此时就会报错编译错误.

在异常处理中，以下描述不正确的有（D）

A try块不可以省略

B 可以使用多重catch块

C finally块可以省略

D catch块和finally块可以同时省略

答案：这里 catch 是不能省略的，本来就是通过catch来捕获我们的异常，如果它都省略了，那么咋来处理异常呢？所以很明显直接选 D

finally ：是可以省略的，如果加上了finally 那么就一定会执行 finally中的代码.

下列描述中，错误的是（C）

A SQL语言又称为结构化查询语言

B java中”static”关键字表明一个成员变量或者是成员方法可以在没有所属的类的实例变量的情况下被访问

C 面向对象开发中，引用传递意味着传递的并不是实际的对象，而是对象的引用，因此，外部对引用对象所做的改变不会反映到所引用的对象上

D java是强类型语言，javascript是弱类型语言

E 面向对象的三大特性包括：封装，继承，多态

答案： C ，这里外部对引用对象的改变会反映到我们的对象上。

下列哪种说法是正确的？（C）

A 实例方法可直接调用超类的实例方法

B 实例方法可直接调用超类的类方法

C 实例方法可直接调用本类的类方法

D 实例方法可直接调用其他类的实例方法

答案： A ：这里我们实例方法想要调用超类(父类)的实例方法需要通过 super. 来调用，所以这里是错误的

B : 实例方法不能直接调用超类的类方法(也就是被 static 修饰的方法) ,这里就需要通过类名进行调用如：Test.sum

C ：正确，我们可以在同一个类中直接调用

D ：我们实例方法去调用其他类的实例方法需要其他类的对象才能调用，所以D也是错的

对于abstract声明的类，下面说法正确的是

A 可以实例化 B 不可以被继承 C 子类为abstract D 只能被继承 E 可以被抽象类继承

答案： A ： 错误被abstract声明的类是抽象类，是不可以被实例化的

被 final 修饰的类是不能够继承的，而被 abstract 修饰的方法是必须需要重写的 B : 抽象类大部分情况下都是需要继承的 ,但不一定非要继承. C : 子类可以是被 abstract ，此时这个子类就可以不重写父类的抽象方法 D : 此时我们的抽象类 B 就被组合了

下面哪些类实现或继承了 Collection 接口？ A HashMap B ArrayList C Vector D Iterator

观察下图我们就能知道谁实现了我们的 Collection接口 . 所以答案为 B C

在JAVA中，假设A有构造方法A(int a)，则在类A的其他构造方法中调用该构造方法和语句格式应该为（）

A this.A(x)

B this(x)

C super(x)

D A(x)

题目给了 A 是有构造方法 A(int a) ，说明是带有一个参数的构造方法，这里我们想要通过 this 调用带有一个参数的构造方法，直接使用 this(x) 即可，这里需要注意this() ，需要在构造方法的第一行 .

在java7中，下列不能做switch()的参数类型是（D）

A int型 B 枚举类型 C 字符串 D 浮点型

答案： D ，这里我们直接特殊记忆一下即可，不能作为 switch() 的参数类型有 float , double , boolean , long

java文件可以包含很多类，并不一定需要与文件名相同，只有public修饰的类与文件名相同

以下代码返回值是什么？

A true B false

这里主要考察异常中 finally 不管是否出现异常都会执行，一开始返回一个 true ，但是需要执行 finally中的代码，所以又执行了一个 return false ，此时最终就返回了一个 false

答案： B

阅读下列程序，选择哪一个是正确的输出结果

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

答案：本题主要考察代码块，复习文章：(56条消息) 继承 Inheritance_

关于代码块的总结：

1、父类静态代码块优先于子类静态代码块执行，且是最早执行

2、父类实例代码块和父类构造方法紧接着执行

3、子类的实例代码块和子类构造方法紧接着再执行

4、第二次实例化子类对象时，父类和子类的静态代码块都将不会再执行

解析：先打印父类的静态代码块，然后打印子类的静态代码块，因为题目中只有构造方法，所以回显执行构造方法，子类构造时会先帮助父类进行构造所以先执行父类的构造方法，在执行子类的构造构造方法，所以答案： C

执行：

7.下列代码的输出结果是？

在这里插入图片描述

A true B false C null D 空字符串

解析：

在这里插入图片描述

所以答案很明显选 B

1.在Java中下面Class的声明哪些是错误的？

A public abstract final class Test { abstract void method(); }

B public abstract class Test { abstract final void method(); }

C public abstract class Test { abstract void method() { } }

D public class Test { final void method() { } }

A : abstract 是定义抽象类或抽象方法的，既然是抽象类就是用来被继承的，而关键字 final 修饰的类是不能继承的，而被 final修饰的方法是不能重写的。所以 abstract 与 final 是不能出现在一起的。所以 A 错误 B : 同上 C : 抽象方法本来就是被重写的所以不需要具体实现，这里就不能带有 {} 所以 C 错误

D ：正确

下列关于构造方法的叙述中，错误的是（CD）

A java语言规定构造方法名与类名必须相同 B java语言规定构造方法没有返回值，但不同void声明 C java语言规定构造方法不可以重载 D java语言规定构造方法只能通过new自动调用

A : 正确 B : 正确 C : 错误，类是可以拥有多个构造方法的，构造方法可以是不带参数，带有一个参数等，此时就满足了重载的规则，所以是可以构成重载的. 重载：方法名相同，返回类型不做要求，参数类型和参数个数不同 .

D : 错误，我们的 this 或 super ，都是可以调用构造方法的， this 调用当前类的构造方法， super 调用父类的构造方法

以下 _D 不是 Object 类的方法

A clone（） B finalize() C toString() D hasNext()

答案：如果不熟悉 Object 源码，这道题就比较难选，下面观察 Object 的方法，就能够发现只有 D 是没有的。

这里 hashNext() ，是属于迭代器 Iterator中的方法。

下列选项中关于 java 中 super 关键字的说法正确的是 (A)

A： super 关键字是在子类对象内部指代父类对象的引用.

B ： super 关键字不仅可以指代子类的直接父类，还可以直接指代父类的父类.

C ：子类通过 super 关键字只能调用父类的方法，而不能调用父类的属性.

D ：子类通过 super 关键字只能调用父类的属性，而不能调用父类的方法 .

答案： A 正确，我们可以通过 super 访问父类的方法和属性以及父类的构造函数

B ：错误， super 直接指向子类的父类，而不能直线子类的爷爷辈 (父类的父类) C , D 都错，super 关键字可以访问父类的属性和方法

如下Java语句，执行后， x的值是（D）

double x= 3.0;

int y=5;

x/=--y; 1 2 3 4 5 A 3

B 0.6

C 0.4

D 0.7

运行异常和非运行异常运行时异常：都是RuntimeException类及其子类异常，如NullPointerException(空指针异常)、IndexOutOfBoundsException(下标越界异常)等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生。运行时异常的特点是Java编译器不会检查它，也就是说，当程序中可能出现这类异常，即使没有用try-catch语句捕获它，也没有用throws子句声明抛出它，也会编译通过。非运行时异常（编译异常）：是RuntimeException以外的异常，类型上都属于Exception类及其子类。从程序语法角度讲是必须进行处理的异常，如果不处理，程序就不能编译通过。如IOException、SQLException等以及用户自定义的Exception异常，一般情况下不自定义检查异常。 —————————————————————————————————————————————

1.在jdk1.5之后，下列 java 程序输出结果为B。

int i=0; Integer j = new Integer(0); System.out.println(i==j); System.out.println(j.equals(i));

A.true,false B.true,true C.false,true D.false,false E.对于不同的环境结果不同 F.程序无法执行

选B i==j ，这个是基本类型与 Integer 的比较， j 会自动拆箱成 int 类型，然后比较的是值。因此返回真。 j.equals(i) ，调用 equals 方法后，这个 i 会自动装箱成 Integer 类型，然后再比较值，所以也真

—————————————————————————————————————————————

以下描述正确的是 A CallableStatement是PreparedStatement的父接口 B PreparedStatement是CallableStatement的父接口 C CallableStatement是Statement的父接口 D PreparedStatement是Statement的父接口他的回答： D (错误) 正确答案： B

Statement 对象用于将 SQL 语句发送到数据库中。实际上有三种 Statement 对象，它们都作为在给定连接上执行 SQL语句的包容器：

Statement、 PreparedStatement（它从 Statement 继承而来）和 CallableStatement（它从 PreparedStatement 继承而来）。它们都专用于发送特定类型的 SQL 语句：

Statement 对象用于执行不带参数的简单 SQL 语句； PreparedStatement 对象用于执行带或不带 IN参数的预编译 SQL 语句； CallableStatement 对象用于执行对数据库已存储过程的调用。 Statement 接口提供了执行语句和获取结果的基本方法。 PreparedStatement 接口添加了处理 IN 参数的方法；而CallableStatement 添加了处理 OUT 参数的方法。 ————————————————

clone()方法创建并返回此对象的一个副本，一般情况下： x.clone().equals(x)为 true；

当WHERE子句、GROUP BY子句、HAVING子句、ORDER BY子句同时出现在一个SQL查询语块中时，最后执行的（D）

A. WHERE子句 B. GROUP BY子句 C. HAVING子句 D. ORDER BY子句答案：D

请注意在 SQL 中，查询中子句的执行顺序通常如下：

FROM 子句：指定从中检索数据的表。 WHERE 子句：根据指定的条件筛选行。 GROUP BY 子句：根据指定的列或表达式对行进行分组。 HAVING 子句：根据条件筛选分组的行。 SELECT 子句：选择将在结果集中返回的列或表达式。 ORDER BY 子句：根据指定的列或表达式对结果集进行排序。 LIMIT/OFFSET 子句：限制结果集中返回的行数。

对于序列{ 12,13,11,18,60,15,7,19,25,100 }，用筛选法建堆，应该从值为（）的数据开始建初始堆

A. 100 B. 12 C. 60 D. 15

序列视为一棵完全二叉树，其最后一个非终端结点是第「n / 2」（向下取整）个元素，以其为根，与其子结点构成一棵树。

已知二叉树后序遍历序列是bfegcda，中序遍历序列是badefcg，它的前序遍历序列是（）

A. abcdefg B. abdcefg C. adbcfeg D. abecdfg 答案：B

如果直到中序和前序，后序中的一种，必须直到前序就能知道另一种排序顺序。

前序：根->左->右 , 中序：左->根->右, 前序：左->右->根

我们拿出来后续bfegcda，根据中序排列。所以根是a,左子树是b且就他一个。 d在a的右边，c在a右边，d的右边，g在a,d,c的右边;e在a,d右边，c，g的左边。如果e画在g的左边在，这样e就不再c的左边了。

————————————————

设哈希表长为8，哈希函数为Hash (key)=key%7。初始记录关键字序列为(32，24，15，27，20，13)，用链地址法作为解决冲突方法的平均查找长度是（B）

A. 1.4 B. 1.5 C. 1.6 D. 1.7

【答案】B