JAVA类与对象及数组习题及答 案

JAVA类和对象及数组习题

一、选择题

（1）下列构造方法的调用方式中，正确的是（ D ）--原因：在通过new 实例化一个类对象时系统会自动调用该类相应的构造方法。

A．按照一般方法调用 B．由用户直接调用

C．只能通过new自动调用 D．被系统调用

（2）在Java中，能实现多重继承效果的方式是（ C ）--原因：一个类可以同时实现多个接口。Java接口反映了对象较高层次的抽象，还弥补了Java只支持单继承的不足，可用它来完成多继承的一些功能。A．内部类 B．适配器 C．接口 D．同步

（3）int型public成员变量MAX_LENGTH，该值保持为常数100，则定义这个变量的语句是( D )—原因：java中定义常量用关键字final来定义。

A．public int MAX_LENGTH=100 B．final int MAX_LENGTH=100 C．public const int MAX_LENGTH=100 D．public final int MAX_LENGTH=100

（4）下列叙述中，正确的是( A )—原因：Java严格区分大小写，所以变量number与Number不相同；Java 中的注释方式除了“//”行注释之外还有段注释“/*-------*/”和文档注释/**-------*/。Java源文件中的public类只能有一个。

　A. 声明变量时必须指定一个类型

　B. Java认为变量number与Number相同

　C. Java中唯一的注释方式是"//"

　D. 源文件中public类可以有0或多个

（5）下列叙述中，错误的是( D )—原因：子类继承父类，并且可以有自己的成员变量和成员方法。所以可以认为子类是父类的扩展。

A. 父类不能替代子类

B. 子类能够替代父类

C. 子类继承父类

D. 父类包含子类

（6）下列代码中，将引起编译错误的行是( B )—原因：定义float型变量并对其初始化时，其值后面要加一个f.

1）public class Exercise{

2） public static void main(String args[]){

3） float f=0.0;

4） f +=1.0;

5） }

6）}

A. 第2行

B. 第3行

C. 第4行

D. 第6行

（7）下列关于继承的哪项叙述是正确的？( D ) –错误原因：JAVA不允许多重继承，但可以通过接口的机制来达到多重继承的目的；一个类可以同时继承一个类和实现多个接口，但是不能同时继承多个类。A．在java中允许多重继承

B．在java中一个类只能实现一个接口

C．在java中一个类不能同时继承一个类和实现一个接口

D．java的单一继承使代码更可靠

（8）下列哪个修饰符可以使在一个类中定义的成员变量只能被同一包中的类访问？( B ) –原因：无修饰符时是缺省修饰，它可以被同一包中的任何类访问。

A．private B．无修饰符 C．public D．protected

（9）给出下列代码，如何使成员变量m 被方法fun（）直接访问？( C ) –原因：静态的成员方法只能访问静态的成员变量。

class Test

{ private int m;

public static void fun（）

{ ... } }

A．将private int m 改为protected int m

B．将private int m 改为 public int m

C．将private int m 改为 static int m

D．将private int m 改为 int m

（10）已知有下列类的说明，则下列哪个语句是正确的？( B )—原因：f是Test类的私有成员变量，在类外不能访问，所以A不对。m是非静态的变量不能直接用类名来访问，所以C不对。由以上两个原因可知D不对。

public class Test

{ private float f = 1.0f;

int m = 12;

static int n=1;

public static void main（String arg［］）

{ Test t = new Test（）; } }

A．t.f； B．this.n； C．Test.m； D．Test.f；

（11）给出下列代码，则数组初始化中哪项是不正确的？( A ) –原

因：array2是一个二维数组，而aray1是一个一维数组。

byte［］ array1,array2［］;

byte array3［］［］;

byte ［］［］ array4;

A．array2 = array1 B．array2=array3

C．array2=array4 D．array3=array4

（12）下列代码的执行结果是( A ) –原因：在非静态的方法中不能定义静态的变量

且方法aMethod没有返回语句。

public class Test

{ public int aMethod（）

{ static int i=0; i++; System.out.println（i）; }

public static void main（String args［］）

{ Test test = new Test（）; test.aMethod（）; } }

A．编译错误 B．0 C．1 D．运行成功，但不输出

（13）下列关于内部类的说法不正确的是( C ) –原因：内部类可以声明为private或protected,还可以声明为abstract或final;

A．内部类的类名只能在定义它的类或程序段中或在表达式内部匿名使用

B．内部类可以使用它所在类的静态成员变量和实例成员变量

C．内部类不可以用abstract修饰符定义为抽象类

D．内部类可作为其他类的成员，而且可访问它所在类的成员

（14）顺序执行下列程序语句后，则b的值是( C ) –原因：String类的substring方法用于返回一个新的字符串对象，在当前字符串中，求以第一个参数为起始索引位置，第二个参数为结束索引位置的子串的值。其中不包括结束索引位置的那个字符。

String a="Hello";

String b=a.substring（0,2）;

A．Hello B．Hel C．He D．null

（15）为AB类的一个无形式参数无返回值的方法method书写方法头，使得使用类名AB作为前缀就可以调用它，该方法头的形式为( A )。--原因：static修饰的方法又称为静态方法。静态方法是类方法，它可以直接通过类来调用，也可以通过类实例来调用。

A．static void method( ) B. public void method( )

C．final void method( ) D. abstract void method

(16) 不使用static修饰符限定的方法称为对象（或实例）方法，下列哪一个说法是正确的？（ D ）--原因：A子类实例方法可以直接调用父类的public和protected实例方法，但不能调用父类的private方法。B类方法也称为静态方法，非静态的方法不能调用静态的方法和成员变量，所以无论是父类还是子类的实例方法都不能调用静态方法。C一个类的实例方法只有这个类的其它方法或对象可以调用，不可以由其它类不经过实例化直接调用。

A.实例方法可以直接调用父类的实例方法。

B.实例方法可以直接调用父类的类方法。

C.实例方法可以直接调用其他类的实例方法。

D.实例方法可以直接调用本类的实例方法

（17）设有下面的一个类定义：

class AA { static void Show( ) { System.out.println(“我喜欢Java!”); } } class BB { void Show( ) { System.out.println(“我喜欢C++!”); } }

若已经使用AA类创建对象a和BB类创建对象b，则下面（ A、C ）方法调用是正确的 –原因：静态方法属于类方法，它可以直接通过类来调用，也可以通过类实例来调用。而非静态的方法则只能通过类实例（对象）来调用。所以AA类的静态show方法即可通过类也可以通过对象来调用，而BB类中的非静态方法show则只能通过对象b来调用。

A. a.Show( ) ; b.Show( )

B. AA.Show( ); BB.Show( );

C. AA.Show( ); b.Show( );

D. a.Show( ); BB.Show( );

(18) 在Java中，一个类可同时定义许多同名的方法，这些方法的形式参数的个数、类型或顺序各不相同，传回的值也可以不相同。这种面向对象程序特性称为（ C ）。

–原因：同一名称的方法实现不同的功能是面向对象的多态性的表现，该多态性也称为重载。

A.隐藏

B.覆盖

C.重载

D.Java不支持此特性

(19) 对于构造函数，下列叙述不正确的是（ C ）。–原因：子类可以通过super来调用父类的构造方法。

A.构造函数也允许重载。

B.子类无条件地继承父类的无参构造函数。

C.子类不允许调用父类的构造函数。

D.在同一个类中定义的重载构造函数可以相互调用。

(20) 对于子类的构造函数说明，下列叙述中不正确的是（ D ）。--原因：子类不可以继承父类的有参构造函数。只能通过super调用。

A.子类无条件地继承父类的无参构造函数。

B.子类可以在自己的构造函数中使用super关键字来调用父类的含参数构造函数，但这个调用语句必须是子类构造函数的第一个可执行语句。

C.在创建子类的对象时，将先执行继承自父类的无参构造函数，然后再执行自己的构造函数。

D.子类不但可以继承父类的无参构造函数，也可以继承父类的有参构造函数。

二、请写出下列程序的运行结果

(1)下列程序的运行结果是( s=120 ) —分析：if语句执行3次，分别是当i=0,3,6时，对应的数组中的数分别为：10，40，70，它们的和为120. public class Examac

{ public static void main(String args[ ])

{ int i , s = 0 ;

int a[ ] = { 10 , 20 , 30 , 40 , 50 , 60 , 70 , 80 , 90 };

for ( i = 0 ; i < a.length ; i ++ )

if ( i%3 == 0 ) s += a[i] ;

System.out.println("s="+s); } }

(2)下列程序的运行结果是( 110 110 110 110 110 )—分析：for循环执行5次，分别输出11+99，22+88，33+77, 44+66, 55+55的和，且之间用空格隔开。

public class Examad

{ public static void main(String args[ ])

{ int i ;

int a[ ] = { 11,22,33,44,55,66,77,88,99 };

for ( i = 0 ; i <= a.length / 2 ; i ++ )

System.out.print( a[i]+a[a.length-i-1]+" ");

System.out.println( ); } }

(3)下列程序的运行结果是( parent

child

child

)—分析：当对象myC调用方法printAll（）后，顺序执行该方法中的三条语句，在子类Child中，重载了父类的printMe方法，所在当执行this.printMe() 和printMe()方法时都调用重载后的printMe()方法。所以依次输出parent,child,child.

class Parent

{ void printMe()

{ System.out.println("parent"); } }

class Child extends Parent

{ void printMe()

{ System.out.println("child"); }

void printAll()

{ super.printMe();

this.printMe();

printMe(); } }

public class Examae

{ public static void main(String args[ ])

{ Child myC = new Child( );

myC.printAll( ); } }

(4)下列程序的运行结果是(

The String No.1 is

The String No.2 is String 2

The String No.3 is string

The String No.4 is string

The String No.5 is string )—原因：s1定义了一个空的字符串对象，所以不会输出任何东西。s2定义了一个字符串对象并赋初值为string2。s3定义了一个以字符数组为参数的字条串对象，并将该字符数组组成的字符串赋给s3。s4定义同s3，只是只取字符数组从索引值为2的字符开始之后的6个字符，所以会去掉前面的两个空格。s5是以一个StringBuffer 类对象为参数定义的一个字符串对象，它的初值同s3.

class Examaf {

public static void main(String args[]) {

String s1=new String();

String s2=new String("String 2");

char chars[]={' ',' ','s','t','r','i','n','g'};

String s3=new String(chars);

String s4=new String(chars,2,6);

byte bytes[]={0,1,2,3,4,5,6,7,8,9};

StringBuffer sb=new StringBuffer(s3);

String s5=new String(sb);

System.out.println("The String No.1 is "+s1);

System.out.println("The String No.2 is "+s2);

System.out.println("The String No.3 is "+s3);

System.out.println("The String No.4 is "+s4);

System.out.println("The String No.5 is "+s5); } }

(5)下列程序的运行结果是(

0 and 0

1 and 0

0 and 1

1 and 1

0 and 2

1 and 2

)—原因：不带标签的break只结束它所在那一层循环不能结束外部循环，所以内层循环只能执行两次，分别是j为0，1时。外层循环执行三次，分别是i为0，1，2时。

public class ExamOuter

{ public static void main(String args[])

{ for(int i=0; i<3; i++)

for(int j=0;j<3;j++)

{ if(j>1) break;

System.out.println(j+" and "+i); } } }

(6)下列程序的运行结果是( 4 )—原因：执行主方法时先对a,b赋初值，然后判断条件，当判断++b==6时，先对b加1再判断，此时b的值已经成为3，条件都不满足，输出a+b的值为1+3=4;

class ExamTest

{ public static void main(String args[])

{ int a=1,b=2;

if((a==0)&(++b==6))

a = 100;

System.out.println(a+b); } }

（7）下列程序的运行结果是(

x=2

st.y=1

st.y=1 )—原因：生成类StaticTest时，先对静态成员变量x赋值1，当执行主方法时，先执行其静态代码块，将x的值加1，此时x=2。在实例化类时因为y并不是静态的，所以它属于对象，不属于类。所以对象中y的初值为0，调用构造方法后对其加1.

class StaticTest

{ static int x=1;

int y;

StaticTest()

{ y++; }

public static void main(String args[ ])

{ StaticTest st=new StaticTest();

System.out.println("x=" + x);

System.out.println("st.y=" + st.y);

st=new StaticTest();

System.out.println("st.y=" + st.y); }

static { x++;} }

（8）下列程序的运行结果是(

x1=0

x3=5

x2=2 )—原因：在生成类时先对类中的静态成员进行初始化分配空间，所以x1先赋值。再执行主函数时，先执行静态代码块，所以输出x3=5,再执行模3运算，x得2赋给x2输出。

class StaticStuff

{ static int x;

static { System.out.println("x1=" + x); x+=5; }

public static void main(String args[ ])

{ System.out.println("x2=" + x); }

static { System.out.println("x3=" + x);x%=3; }

}

（9）下列程序的运行结果是(

2

2

3

)—原因：当调用子类无参构造方法时，就调用父类的的无参构造方法，该方法调用func()函数，而该函数被子类覆盖，所以会调用子类的func()函数。当执行第二条语句调用子类的含参构造方法时，系统会默认先调用父类的无参构造方法再调用子类含参构造方法。

class Person

{ public Person () { func(); }

public void func() { System.out.println("1 "); } }

public class Person_A extends Person

{ public Person_A() {super();}

public Person_A(int a) {System.out.println(a);}

public void func() {System.out.println("2 ");}

public static void main(String[] args)

{ Person_A pa = new Person_A();

Person_A pb = new Person_A(3); } }

（10）父类与子类初始化顺序：(

父类静态变量

父类静态代码块

子类静态变量

子类静态代码块

父类代码块

父类非静态变量

A Person.

子类代码块

子类非静态变量

A chinese.

true )—原因：无论是静态方法，静态变量还是静态代码块都是属于类的，不属于对象，所以无论有无对象生成，类中的静态成员都会初始化，函数也可以随时由类调用。因为子类继承父类，也即先有父类，所以会先初始化父类的静态成员。当子类生成对象时系统默认调用父类的无参构造方法，并对父类已经初始化的成员变量分配空间并执行父类代码块，然后子类再重复此过程。

class Person

{ { System.out.println("父类代码块"); }

int m=f();

int f() {System.out.println("父类非静态变量"); return 1; }

static int n=g();

static { System.out.println("父类静态代码块"); }

static int g(){System.out.println("父类静态变量");return 2;}

Person() { System.out.println("A Person."); }

}

public class Chinese extends Person

{ { System.out.println("子类代码块");}

int k=k();

int k() { System.out.println("子类非静态变量"); return 3; }

static int i=i();

static int i() { System.out.println("子类静态变量");return 4; }

static{ System.out.println("子类静态代码块"); }

Chinese() { super(); System.out.println("A chinese."); }

public static void main(String[] args)

{ Chinese obj=new Chinese();

// boolean b=obj instanceof Chinese;//应该去掉注释，否则程序编译出错。

System.out.println(b);

}

}