选择题 | 6 Java类的特殊成员

1．类中存在一个方法int getValue(int x){…}，以下能与这个方法重载的是（C）。

A．public getValue(int x){…};

B．void getValue(int x){…};

C．int getValue(int x, int y){…};

D．int get(int x){…};

2．类中存在一个方法int getValue(double x){…}，以下不能与这个方法重载的是（C）。

A．int getValue(int x){…};

B．int getValue(float x){…};

C．int getValue(double t){…};

D．int getValue(double x, double y){…};

3．以下关于重载的说法错误的是（A）

A．重载的方法只要定义正确，调用时就不会有歧义性。

B．重载的方法通常实现相似的功能

C．重载的方法可以互相调用，提高代码复用

D．重载是多态的一种表现形式

4．已知A类具有以下四个成员方法，a是A类的对象，则a.fun(1, 3.14F)调用的是（D）。

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

B．public int fun(double a, double b){…}

C．public void fun(float a, float b){…}

D．public float fun(int a, float b){…}

5．下列不是重载方法的特征的是（B）。

A．参数个数不同

B．返回值类型不同

C．参数类型不同

D．方法名相同

6．一个类可同时定义许多同名的方法，这些方法的形式参数个数、类型或顺序各不相同，传回的值也可以不相同，这种特性称为（C）。

A．继承

B．重写

C．重载

D．封装

7．以下类定义中错误的方法调用语句是（D）。

public class Test {

public void fun(int a, double b) {}

public void fun(long a, float b) {}

public void testFun() {

fun(1, 3.14); //语句A

fun(1L, 3.14F); //语句B

fun('1', 3.14); //语句C

fun(1, 3.14F); //语句D

}

}

A．语句A

B．语句B

C．语句C

D．语句D

8．以下类定义中错误的方法调用语句是（A）。

public class Test {

public Test() {

Test(0); //语句A

}

public Test(int a) {}

public void fun() {

fun(0); //语句B

}

public void fun(int a) {}

public static void main(String args[ ]) {

Test t1 = new Test(0);

Test t2 = new Test();

t1.fun(0); //语句C

t2.fun(); //语句D

}

}

A．语句A

B．语句B

C．语句C

D．语句D

9．定义类属性或类方法使用修饰符（A）。

A．static

B．package

C．private

D．public

10．对以下类说法正确的是（D）。

class Demon {

double x;

static int y;

}

A．x称为类变量，y为实例变量

B．x、y均为类变量

C．x、y均为实例变量

D．x为实例变量，y为类变量

11．下列关于静态属性的描述中错误的是（A）。

A．静态属性只能通过类名访问，不能通过对象名访问

B．静态属性可以通过类名访问，也可以通过对象名访问

C．无论创建类的多少个实例，一个静态属性都被所有实例共享

D．用关键字static修饰的成员变量为静态属性

12．下列关于实例属性的描述中错误的是（B）。

A．实例属性只能通过对象名访问，不能通过类名访问

B．类的不同实例可以共享相同的实例属性空间

C．不使用static修饰符的成员变量为实例属性

D．实例变量取决于类的实例，每创建一个实例就会为其实例变量分配一次内存

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

public class Test {

public int a = 0;

public static void main(String args[ ]) {

System.out.println(Test.a);

}

}

A．编译错误

B．运行时异常

C．输出0

D．输出null

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

public class Example {

public static void main(String args[ ]) {

static int x[ ] = new int[15];

System.out.println (x[5]);

}

}

A．编译错误

B．运行时异常

C．输出0

D．输出null

15．下列关于静态方法的描述中错误的是（D）。

A．可以使用"类名.方法名"来调用静态方法

B．可以使用"对象.方法名"来调用静态方法

C．程序的入口点main()方法必须被定义为静态方法

D．构造方法不可以定义为静态方法

16．下列关于静态方法和实例方法的描述中错误的是（B）。

A．静态方法可以通过成员名直接访问同类静态成员

B．静态方法可以通过成员名直接访问同类实例成员

C．实例方法可以通过成员名直接访问同类静态成员

D．实例方法可以通过成员名直接访问同类实例成员

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

class A {

private int counter = 0;

public static int getInstanceCount() {

return counter;

}

public A() {

counter ;

}

}

public class Test {

public static void main(String args[ ]) {

A al = new A();

A a2 = new A();

System.out.println(A.getInstanceCount());

}

}

A．输出1

B．输出2

C．运行时异常

D．编译错误

18．已知obj是如下定义的类Obj的对象，错误的方法调用是（A）。

class Obj{

intx, y;

staticdouble f(int a){…}

doubleg(int x1, intx2){…}

}

A．Obj.g(3, 2)

B．Obj.f(3)

C．obj.f(4)

D．obj.g(2, 5)

19．一个静态方法不可能具有的特点是（C）。

A．方法体只访问方法的参数

B．方法体只访问同类的静态成员

C．方法体只访问同类的实例成员

D．方法体不访问同类的任何成员

20．以下类定义中错误的语句是（B）。

public class Test {

int a;

static int b;

void fun1() {

a = 1; //语句A

b = 1; //语句B

fun2(); //语句C

}

static void fun2() {

a = 1; //语句D

b = 1; //语句E

}

static void fun3() {

fun1(); //语句F

}

}

A．语句A和语句D

B．语句D和语句F

C．语句C和语句E

D．语句B和语句C

21．类A具有一个无形式参数无返回值的方法method，为了使用A.method()就可以调用它，该方法的形式可以为（A）。

A．static void method(){}

B．public void method(){}

C．final void method(){}

D．abstract void method(){}

22．关于下面的程序说法正确的是（D）。

public class Test {

String x = "1";

int y;

public static void main(String args[ ]) {

int z = 2;

System.out.println(x y z);

}

}

A．3

B．102

C．12

D．编译错误

23．下列关于this的描述中，错误的是（D）。

A．每个对象都有一个名为this的引用，它指向当前对象本身

B．this可以用于访问本类的成员变量

C．this可以用于访问本类的成员方法

D．this可以出现在static方法中

24．this关键字的含义是表示（B）。

A．当前变量

B．当前对象

D．当前类

D．当前方法

25．以下类定义中this使用有错误的语句是（C）。

public class Test {

int a;

static int b;

Test(int a) {

this.a = a;

this.fun1(0); //语句A

}

Test() {

this(0); //语句B

}

static void fun2(int a) {

this.a = a; //语句C

}

void fun1(int b) {

this.b = b; //语句D

}

}

A．语句A

B．语句B

C．语句C

D．语句D

26．成员的访问限定符不包括（D）。

A．public

B．private

C．default

D．final

27．以下类中定义正确的是变量（C）。

public class Test {

final f1= 'f';

final int f2 = 1.2;

static final float f3 = 213.34f;

static final long f4;

}

A．f1

B．f2

C．f3

D．f4

28．以下关于类的final成员变量说法正确的是（A）。

A．可以在定义时或在构造方法中初始化

B．可以在任意成员方法中赋值

C．对于一个类的所有对象，同名final成员变量的值都相同

D．如果没有在定义时或构造方法里初始化，则被初始化为默认值

29．以下关于final和static关键字的说法正确的是（C）。

A．都可以修饰成员方法、成员变量和构造方法

B．都可以修饰局部变量

C．用static final同时修饰的成员变量不能在构造方法中初始化

D．不可以使用static final同时修饰成员方法或成员变量

30．以下程序的运行结果是（A）。

public class Test {

private final int id;

public Test(int id) {

this.id = id;

}

public void updateId(intnewId) {

id = newId;

}

public static void main(Stringargs[ ]) {

Test fa = new Test(42);

fa.updateId(69);

System.out.println(fa.id);

}

}

A．编译错误

B．运行时异常

C．42

D．69

31．以下关于toString()方法的说法不正确的是（D）。

A．所有类都有隐含的toString()方法，默认返回对象地址相关的字符串

B．可以按照需要重新定义toString()方法返回自定义的字符串

C．当对象需要作为字符串使用时toString()通常将被自动调用

D．若类没有定义toString()方法，则不能调用该方法

32．已知TestToString类定义如下，t是TestToString类的对象，则有错误的语句是（B）。

class TestToString {

public String toString() {

return "toString";

}

}

A．String s1 = t.toString();

B．String s2 = t '1';

C．String s3 = t "1";

D．System.out.println(t);

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

public class Test {

protected int a;

public Test(int a) {

this.a = a;

}

public static void main(String[ ] args) {

Test a = new Test(1);

System.out.println(a);

}

}

A．1

B．0

C．不确定

D．编译错误

34．以下关于类的equals()说法正确的是（B）。

A．所有的类都有隐含的equals()方法，默认对比当前对象和形式参数引用的对象的属性是否相同

B．定义一个类时可以按照需要重新定义equals()方法

C．比较对象时，equals()方法和==的作用完全相同，只能比较两个变量是否引用同一对象

D．若一个类没有定义equals()方法，则不能调用该方法

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

public class Test {

protected int a, b;

public Test(int a, int b) {

this.a = a;

this.b = b;

}

public boolean equals(Test te) {

return te.b == this.b;

}

public static void main(String[ ] args) {

Test a = new Test(3, 4);

Test b = new Test(1, 4);

System.out.println(a.equals(b));

}

}

A．true

B．false

C．不确定

D．编译错误

36．以下程序的输出结果是（B）。

public class Test {

protected int a, b;

public Test(int a, int b) {

this.a = a;

this.b = b;

}

public boolean equals(Test te) {

return te.a == this.a