选择题 | 9 Java类的扩展

1．下列关于继承的说法中错误的是（C）。

A．继承具有传递性

B．继承关系也称为"即是"(is a)关系

C．Java支持一个类继承多个类

D．继承提高了代码的可重用性

2．下列关于继承的说法中正确的是（D）。

A．一个类最多只能被一个类继承

B．所有的类都能被继承

C．子类只能继承父类的成员变量，不能继承成员方法

D．如果A类继承B类，B类继承C类，则A类间接继承C类

3．以下两个类之间的关系是（B）。

class Road{

Stringname;

}

class Bridge{

Roadroad;

}

A．"是什么(is a)"关系

B．"有什么(has a)"关系

C．A和B都是

D．A和B都不是

4．以下两个类之间的关系是（A）。

class Phone {

public void Call(){}

}

class SmartPhone extends Phone {

public void Surf(){}

}

A．"是什么"关系

B．"有什么"关系

C．A和B都是

D．A和B都不是

5．下列选项中，用于在定义子类时声明父类名的关键字是（C）。

A．interface

B．package

C．extends

D．class

6．下列关于继承的说法中错误的是（B）。

A．如果子类成员变量和父类成员变量的名字相同，访问父类成员变量必须用super关键字说明

B．如果子类成员方法和父类成员方法的名字相同，无论参数是否相同，访问父类成员方法必须用super关键字说明

C．子类的成员变量可以和父类的成员变量名字相同

D．子类的成员方法可以和父类的成员方法完全相同

7．关于Object类，以下说法错误的是（A）。

A．定义类时经常重载Object的public String toString()方法以生成对象的字符串表示

B．定义类时经常重载或重写Object类public boolean equals(Object obj)方法以对比两个同类对象的属性是否相同

C．如果一个类的声明没有用extends指名父类，则默认继承Object类

D．所有类都是Object类的直接或间接子类

8．关于静态成员，以下说法错误的是（C）。

A．父类的静态成员属于父类的所有对象，因而也属于子类的所有对象，与继承无关

B．父类的静态成员可以通过子类名.成员名访问

C．子类继承父类的静态成员，并且可以隐藏父类的静态变量或重写父类的静态方法

D．子类可以定义同父类静态成员变量同名的静态成员变量，也可以定义同父类静态成员方法同名同参数的静态成员方法

9．以下不是关键字super的作用的是（D）。

A．引用父类的成员变量

B．调用父类的成员方法

C．调用父类的构造方法

D．引用父类方法中的局部变量

10．以下关于父类与子类构造方法的叙述中正确的是（A）。

A．子类构造方法需调用父类构造方法，如果没有调用则自动调用父类的默认构造方法

B．子类构造方法必须在方法体的第一行用super调用父类构造方法

C．子类构造方法调用父类构造方法的格式为"构造方法名(参数)"

D．子类构造方法可以通过赋值初始化全部成员变量而不必调用父类构造方法

11．如果一个类被声明为final类，则下列说法错误的是（A）。

A．说明此类不能生成对象

B．说明此类是最终类，不能被继承

C．此类中的方法不能被覆盖

D．此类中的变量不能被隐藏

12．下列关于final关键字的应用正确的是（D）。

A．声明final类

B．声明final成员方法

C．声明final成员变量和局部变量

D．以上声明都正确

13．以下关于重写与重载的关系叙述不正确的是（A）。

A．final修饰的方法可以被重写，但不能被重载

B．重写只发生在父类与子类之间，而重载可以发生在同一个类中

C．重写和重载都针对同名方法

D．重写要求参数必须相同，重载要求参数必须不同

14．以下关于方法重写规则的叙述中错误的是（D）。

A．方法名必须相同

B．访问权限不能变小

C．返回值类型不能变大

D．参数必须相同，包括参数的类型、个数、顺序和名字

15．以下类定义的横线处必须填写的是（C）。

class Base {

public int b;

}

class Derived extends Base {

public int getB() {

returnb;

}

}

A．super.

B．this.

C．不用写

D．A和B都可以

16．以下类定义的横线处必须填写的是（D）。

class Base {

public int b;

}

class Derived extends Base {

public void setB(int b) { //用参数b修改成员变量b

b = b;

}

}

A．super.

B．this.

C．不用写

D．A和B都可以

17．以下类定义的横线处必须填写的是（A）。

class Base {

public int b;

}

class Derived extends Base {

public String b;

public void setB(int b) { //用参数b修改成员变量b

b = b;

}

}

A．super.

B．this.

C．不用写

D．A和B都可以

18．以下类定义的横线处必须填写的是（B）。

class Base {

public int b;

}

class Derived extends Base {

public String b;

public void setB(String b) { //用参数b修改成员变量b

b = b;

}

}

A．super.

B．this.

C．不用写

D．A和B都可以

19．若父类有方法public int fun(int a){…}，则子类中可以出现的是（D）。

A．public double fun(int a){…}

B．private void fun(int a){…}

C．int fun(int b){…}

D．public int fun(double d) {…}

20．若父类有方法public String fun(int a){…}，则子类中不可以出现的是（A）。

A．public void fun(int a){…}

B．private void fun(double a){…}

C．int fun(){…}

D．public String fun(int b) {…}

21．以下关于上溯造型的说法错误的是（C）。

A．将子类引用上塑造型为父类引用是安全的

B．将子类引用上溯造型为父类引用后不能访问子类特有的方法和变量，但可以访问子类重写的方法

C．若子类中重载了父类中的方法，则子类引用上溯造型为父类引用后，子类中重载方法可以访问

D．上溯造型使得方法的父类型的形式参数可以接受所有子类型对象，父类型的数组可以存储所有子类型的对象

22．关于下溯造型说法错误的是（A）。

A．如果不将父类引用下溯造型为子类型，则不能访问子类中重写的方法

B．下溯造型可能是不安全的，要用instanceof运算符检查类型

C．下溯造型可以恢复访问子类特有的变量和方法

D．如果不将父类引用下溯造型为子类型，则不能访问子类中和父类中同名的变量，即隐藏了父类成员变量的成员变量

23．已知Integer i = 1;，则语句System.out.println(i instanceofString);的输出结果为（A）。

A．编译错误

B．true

C．false

D．不确定

24．已知A派生出子类B，B派生出子类C，且三个类都有默认构造方法，则以下语句中错误的是（A）。

A．C c1 = new B();

B．A a1 = new B();

C．A a2 = new C();

D．B b1 = new C();

25．已知B类继承A类，且已定义B b = new B();，则以下语句中错误的是（C）。

A．A a = b;

B．A a = new B();

C．A a = new B(); B ba = a;

D．A a = new B(); B ba=(B)(a);

26．已知C类和B类都继承A类，且已定义B b = new B(); C c = new C();，则以下语句中错误的是（D）。

A．A a = new B(); a=b;

B．b=c;

C．b=(B)(c);

D．B和C都有错误

27．已知A派生出子类B，B派生出子类C，且已定义B b = new B(); C c = new C();，则以下表达式结果为false的是（B）。

A．b instanceof A

B．b instanceof C

C．c instanceof A

D．c instanceof C

28．已知Son类继承Father类且都有默认构造方法，则关于以下代码正确的说法是（C）。

Father f = new Father(); //第1行

Son s = (Son)(f); //第2行

A．只有第1行能通过编译

B．两行都能通过编译，并正确运行

C．两行能通过编译，但第2行运行时出错

D．两行都不能通过编译

29．以下程序的输出结果是（A）。

class Father {

Father(){

System.out.print("父类的构造方法");

}

}

class Child extends Father{

Child(){

System.out.print("子类的构造方法");

}

}

public class Demo{

publicstatic void main(String[ ] args){

Childc = new Child();

}

}

A．父类的构造方法子类的构造方法

B．子类的构造方法父类的构造方法

C．父类的构造方法

D．子类的构造方法

30．已知类定义如下，且已定义A a = new B();，则a.t的值为（A）。

class A {

int t = 0;

}

class B extends A {

int t = 1;

}

A．0

B．1

C．不确定

D．以上都不正确

31．已知类定义如下，且已定义A a = new B();，则((B)(a)).t的值为（B）。

class A {

int t = 0;

}

class B extends A {

int t = 1;

}

A．0

B．1

C．不确定

D．以上都不正确

32．已知类定义如下，且已定义A a = new B();，则a.fun()的值为（B）。

class A {

public int fun() {

return 0;

}

}

class B extends A {

public int fun() {

return 1;

}

}

A．0

B．1

C．不确定

D．以上都不正确

33．以下程序的结果是（B）。

class Base {

protected int b = 0;

}

class Derived extends Base {

protected int d = 1;

}

public class Test {

public static void main(String[ ] args) {

Base b1 = new Derived();

System.out.println(b1.d);

}

}

A．运行错误

B．编译错误

C．0

D．1

34．以下程序的结果是（B）。

class Base {

protected void fun(){

System.out.println(0);

}

}

class Derived extends Base {

protected void fun(int i){

System.out.println(1);

}

}

public class Test {

public static void main(String[ ] args) {

Base b1 = new Derived();

b1.fun(1);

}

}

A．运行错误

B．编译错误

C．0

D．1

35．以下程序的结果是（D）。

class Base {

protected void fun(){

System.out.println(0);

}

}

class Derived extends Base {

protected void fun(int i){

System.out.println(1);

}

}

public class Test {

public static void main(String[ ] args) {

Base b1 = new Derived();

((Derived)(b1)).fun(1);

}

}

A．运行错误

B．编译错误

C．0

D．1

36．以下程序的结果是（A）。

class Base {

protected void fun(){

System.out.println(0);

}

}

class Derived extends Base {

protected void fun(int i){

System.out.println(1);

}

}

public class Test {

public static void main(String[ ] args) {

Base b1 = new Base();

((Derived)(b1)).fun(1);

}

}

A．运行错误

B．编译错误

C．0

D．1

37．以下语句有错误的是（D）。

A．int a[ ] = {1, 2}; Object o1 = a;

B．Object o2 = "1";

C．Object o3[ ] = {1, "1",'1'};

D．Object o4 = {1, "1",'1'};

38．以下程序的输出结果是（A）。

String s1 = "12", s2 ="34";

Object o[ ] = {s1, s2};

System.out.println(o[0] o[1]);

A．编译错误

B．运行错误

C．1234

D．46

39．以下关于多态的描述中错误的是（C）。

A．重载和重写都是多态的表现形式

B．多态性分为动态多态性和静态多态性两种

C．多态性可以加快代码的运行速度

D．多态性是面向对象的核心特征之一

40．以下程序的结果是（D）。

class Base {

protected void fun(){

System.out.println(0);

}

}

class Derived extends Base {

protected void fun(){

System.out.println(1);

}

}

public class Test {

public static void main(String[ ] args) {

Base b1 = new Derived();

b1.fun();

}

}

A．运行错误

B．编译错误

C．0

D．1

41．以下程序的输出结果是（C）。

class Father {

Father(inta){

System.out.print("父类的构造方法");

}

}

class Child extends Father{

Child(){

System.out.print("子类的构造方法");

}

}

public class Demo{

publicstatic void main(String[ ] args){

Childc = new Child();

}

}

A．父类的构造方法子类的构造方法

B．子类的构造方法父类的构造方法

C．编译错误

D．子类的构造方法

42．以下程序的输出结果是（A）。

class Father {

Father(int a) {

System.out.print("父类的构造方法");

}

}

class Child extends Father {

Child(int a) {

super(a);

}

Child() {

this(0);

System.out.print("子类的构造方法");

}

}

public class Demo{

publicstatic void main(String[ ] args){

Childc = new Child();

}

}

A．父类的构造方法子类的构造方法

B．子类的构造方法父类的构造方法

C．编译错误

D．子类的构造方法

43．以下程序的输出结果是（C）。

class Father {

Father(inta){

System.out.print("父类的构造方法");

}

}

class Child extends Father{

}

public class Demo{

publicstatic void main(String[ ] args){

Childc = new Child();

}

}

A．父类的构造方法

B．无输出

C．编译错误

D．运行错误

44．下列关于包的描述中错误的是（D）。

A．使用包的原因之一是避免类名重复

B．包是由.class文件组成的一个集合，是一个文件夹

C．功能相同或者相关的类一般组织在一个包中

D．包只能定义一层，即包中不能再有包

45．下列关于打包的描述中，错误的是（B）。

A．一个源文件中最多包含一条package语句，且必须是第一条语句

B．一个源文件中定义的类的字节码可以存放于不同的包中

C．若源文件中没有包含package语句，则类的字节码被放入无名包中

D．不在一个源文件中定义的子类和父类可以位于不同包中

46．下列关于引入包的描述中，错误的是（D）。

A．使用项目中其他包中的类时，需要在源程序中写import语句

B．import语句写在类声明的上面，package语句的下面

C．import可以引入包中所有类或其中一个类

D．import语句必须是源文件中第一条语句

47．Java的核心包中，提供编程应用的基本类包是（B）。

A．java.util

B．java.lang

C．java.applet

D．java.rmi

48．下列修饰符中与访问控制无关的是（D）。

A．private

B．public

C．protected

D．default

49．如果希望类中成员能被所有子类继承后像自身成员一样直接访问，则应该使用修饰符（B）。

A．default

B．protected

C．不写

D．private

50．如果希望类中成员即使被子类继承也只能通过父类方法间接访问，则应该使用修饰符（D）。

A．public

B．protected

C．不写

D．private

51．如果类中成员的定义没有用访问权限修饰符，则该成员不能被（D）访问。

A．同一个包中子类

B．子类

C．同一个包中其他类

D．其他包中所有类

52．以下程序的输出结果是（C）。

class Base {

private int a = 0;

}

class Derived extends Base {

public int showA() {

System.out.println(super.a);

}

public static void main(String args[ ]) {

Derived d = new Derived();

d.showA();

}

}

A．0

B．不确定

C．编译错误

D．运行错误

53．以下程序的输出结果是（A）。

class Test {

private int a = 0;

private void show(Test t) {

System.out.println(t.a);

}

public static void main(String args[ ]) {

Test t1 = new Test(), t2 = new Test();

t1.show(t2);

}

}

A．0

B．不确定

C．编译错误

D．运行错误

54．以下不是面向对象特征的是（B）。

A．继承

B．代码复制

C．封装

D．多态

55．以下没有体现出封装性的是（C）。

A．将类的成员用访问权限修饰符加以访问控制

B．提供成员方法操作成员变量

C．将类的全部成员都设定为public权限

D．将类按照不同的包组织管理

56．对于私有构造方法，以下说法正确的是（C）。

A．构造方法如果被限定为private则会产生编译错误

B．不能通过私有构造方法产生类的对象

C．私有构造方法不能在类外通过new调用创建对象

D．具有私有构造方法的类不能被继承

57．下列关于抽象方法的描述中，错误的是（B）。

A．抽象方法声明只需给出方法头，不能写方法体，直接以分号结束

B．所有的方法都可以声明为抽象方法

C．构造方法不能声明为抽象方法

D．声明抽象方法使用关键字abstract修饰

58．以下说法正确的是（D）。

A．final可修饰类、属性和方法

B．abstract可修饰类和方法

C．关键字final和abstract不能同时修饰类或方法

D．以上说法都正确

59．下列关于抽象类的描述中，错误的是（C）。

A．抽象类中可以包含抽象方法，也可以不包含抽象方法

B．抽象类不能实例化，即使抽象类中没有声明抽象方法，也不能实例化

C．不能声明抽象类的变量(对象)

D．包含抽象方法的类，必须要声明为抽象类

60．以下程序的输出结