Java基础阶段测试(含答案)

Java基础阶段测试一

一、选择题：（20分）

1、下列叙述中，正确的是：（）

A声明变量时必须指定一个类型B、Java认为变量number和Number 相同

C、Java中唯一的注释方式是“//”

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

个

2、在switch(expression)语句中，expression的数据类型不能是：A

A、double

B、char

C、byte

D、short

3、已知int[] a =new int[100]；，在下列给出的数组元素中，非法的是：D

A、a[0]

B、a[1]

C、a[99]

D、a[100]

4、下列语句序列执行后，x 的值是( A )。

int a=3, b=4, x=5;

if( ++a

A、 5

B、 3

C、 4

D、6

5、设x,y 均为已定义的类名，下列声明对象x1的语句中正确的是( C )。

A、public x x1= new y( );

B、x x1=x( );

C、x x1=new x( );

D、int x x1;

6、有一个类A，以下为其构造函数的声明，其中正确的是(B)。

A、void A(int x){...}

B、A(int x){...}

C、a(int x){...}

D、void a(int x){...} 7．Java语言的类间的继承关系是( B)。

A、多重的

B、单继承

C、线程的

D、不能继承

8、下面说法正确的是( A)。

A、final 可修饰类、属性、方法。

B、abstract可修饰类、属性、方法。abstract可修饰类、方法。

C、定义抽象方法需有方法的返回类型、名称、参数列表和方法体（没有方法体）。

D、用final修饰的变量（常量），在程序中可对这个变量的值进行更改。

9、对于下列代码：

1) class Person {

2) public void printValue(int i, int j) {//... }

3) public void printValue(int i){//... }

4) }

5) public class Teacher extends Person {

6) public void printValue() {//... }

7) public void printValue(int i) {//...}

8) public static void main(String args[]){

9) Person t = new Teacher();//赋值兼容规则

10) t.printValue(10);

11) }

第10行语句将调用哪行语句？（ D ）

A、line2

B、line3

C、line 6

D、line 7

10下面关于java中类的说法哪个是不正确的（ c ）

A、类体中只能有变量定义和成员方法的定义，不能有其他语句。

B、构造函数是类中的特殊方法。

C、类一定要声明为public的，才可以执行。

D、一个java文件中可以有多个class定义（但只能有一个Public修饰

的类）。

11、给出一段程序，选择运行结果（）

public class sss {

public static void main(String args[])

{

String s1=args[1]; String s2=args[2];

String s3=args[3]; String s4=args[4];

System.out.println(“args[2]=”+s2);

}

}

命令行执行：java sss 1 2 3 4 结果是下面哪一个？

A、args[2]=2

B、args[2]=null

C、args[2]=1

D、运行出现异常

12、下面的是关于类及其修饰符的一些描述，正确的是：（）。

A、abstract类只能用来派生子类，不能用来创建abstract类的对象（可以用赋值兼容规则）。

B、final类不但可以用来派生子类，也可以用来创建final类的对象。

C、abstract不能与final同时修饰一个类。

D、abstract方法必须在abstract类中声明，但abstract类定义中可以没有abstract方法。

13、下列关于静态初始化器的叙述中，哪一个是正确的？（）

A、静态初始化器是在构造函数之前加上static修饰符。

B、静态初始化器是对类自身进行初始化。

C、静态初始化器在同一个类中只能有一个。

D、静态初始化器是在其所属的类加载内存时由系统自动调用执行。

14、编译并运行下面的程序，运行结果为().

public class T1 {

public static void main (String[] args){

T1 a=new T1();

a.method(8);

a.method(1.2f);

}

void method(float i) {

System.out.println("float: "+i);

}

void method(long i) {

System.out.println("long: "+i);

}

}

A、程序有编译错误，因为两个method()方法必须定义为静态（static）的。

B、程序可以编译运行，输出结果为：

long: 8

float: 1.2

C、程序可以编译运行，输出结果为：

float: 1.2

long: 8

D、程序中定义的两个参数不同的method方法称为方法重栽。

15、编译并运行下面的程序，运行结果为( ).

public class A {

public static void main (String[] args) {

A a=new B( );

a.test();

}

void test() {

System.out.print ("A");

}

}

class B extends A {

void test() {

super.test();

System.out.println("B");

}

}

A、子类B定义了与父类A中同名的方法test，java中称为方法的覆盖。

B、代码可以编译运行，并输出结果：AB

C、代码可以编译运行，并输出结果：A。

D、子类B定义了与父类A中同名的方法test，java中称为方法的重载

16、下面哪个说法正确( )

A、如果某公共的接口被声明在一个源文件中，则接口必须与源文件具有相同的名字。

B、如果源文件包含import语句，则该语句必须是除空行和注释行外的第一个语句行。

C、如果某源文件包含package语句，则该语句必须是第一个非空、非注释行。

D、接口中的方法必定是抽象方法，但可以不用关键字abstract修饰。

17、类的设计要求它的某个成员变量不能被外部类直接访问。应该使用下面

的哪些修饰符获得需要的访问控制?

A、public

B、no modifier

C、protected（权限仅次于public）

D、private

18、哪些返回true ? [多选]

String s= "hello";

String t = "hello";

char c[] = {'h','e','l','l','o'} ;

A、s.equals(t);

B、t.equals(c);

C、s==t;

D、t.equals(new String("hello"));

E、t==c.

19、类Teacher和Student都是类Person的子类

Person p;

Teacher t;

Student s;

p, t and s are all non-null.

if(t instanceof Person) { s = (Student)t; }

这个语句导致的结果是什么?

A、将构造一个Student对象。

B、表达式合法。

C、编译时非法。

D、编译时合法而在运行时可能非法。

20、给出下面的代码：

class Person {

String name,department;

public void printValue(){

System.out.println("name is "+name);

System.out.println("department is "+department);

}

}

public class Teacher extends Person {

int salary;

public void printValue(){

// doing the same as in the parent method printValue()

// including print the value of name and department.

System.out.println("salary is "+salary);

}

}

下面的哪些表达式可以加入printValue()方法的"doing the same as..."部分?

A、printValue();

B、this.printValue();

C、person.printValue();

D、super.printValue().

二、简答题：（48分）

1、简答方法的OverLoading和Overriding区别。（笔试题）

（1）OverLoading:方法重载是指方法名相同，参数类型及参数个数不同的一组方法，在调用是根据传入参数不同调用同名的不同方法

（2）Overriding：方法重写是指子类继承父类时，在子类中定义与父类返回值类型相同、方法名相同、参数列表相同，子类访问权限大于或等于父类，如果有异常，子类抛出的异常小于或等于父类的。但是方法体不同的方法

2、简答Java实现动态多态的手段。

（1）多态：相同的消息被不同的对象接受，产生不同的行为结果。

相同的消息是指同名方法调用。

（2）动态多态实现的方式：通过抽象类或者是借口中定义的抽象方法，然后由子类或者接口的实现类实现后，并使用兼容复制规则，实现子类或者实现类方法的动态调用

（1）定义抽象父类，在父类中定义抽象的方法；

父类被不同的子类继承时，子类重写父类定义的抽象方法；

（2）定义不同类共有方法的接口，在类实现时实现接口。

3、简答this和super的用法。

（1）this用在构造方法中第一条语句，形如this([参数列表])表示对本类其他构造方法的调用，用在非静态的成员方法中使用形如this。成员名表

示对本类成员的调用。

（2）super出现在子类构造方法的第一行，形如super.([参数列表])表示对付类构造方法的调用，在子类方法中形如super.成员名，表示对被子类覆盖的父类成员的调用

（1）this 表示对本类成员和方法的引用

（2）super表示对父类方法的调用，必须在方法体的第一行

4、简答抽象类和接口的区别。

（1）抽象类处于类族中的顶层，提供允许子类继承的机制，可以定义抽象方法和非抽象方法，也可以定义构造方法和其他的成员变量，也可以定义常量，抽象类不能实例化。

（2）接口定义了类的共同行为，这些行为方法都是抽象的，接口中不能定义非抽象方法和成员变量，接口允许多继承，按照功能，接口可以非为三类：普通接口，常量群接口和标记性接口（系统定义使用），接口不能实例化。

（1）抽象类是对具有相同属性和行为的一组对象的高度概括，是一个高度概括的父类

（2）接口是对具有相同行为的一组对象的概括，这对对象可能继承与一个父类，也可以继承不同的父类

5、简述类族中构造方法的定义和调用次序。

（1）构造方法：方法名和类名相同，没有返回值类型

（2）父类如何定义构造方法：父类如果定义了带参数的构造方法一般需要定义无参构造

（3）子类如何定义构造方法：子类定义构造方法可以调用本类的其他构

造方法，也可以调用父类的构造方法

（4）调用次序：首先指向弗雷的构造方法之后在定义本类的构造方法

class A{

A(){}

}

class B entends A{

B(){}

}

class C extends B{

C(){}

}

在创建C类对象调用构造方法时：先到用Object类的构造方法在调用A 类的构造方法，然后调用B类的构造方法、最后调用C类的构造方法

6、如何定义包、和使用包中的定义，使用时应该注意哪些事项。

定义包时包必须方在类的最上面第一行，包名必须小写，多级包之间用“.”

间隔

一般定义格式：公司域名的倒置.模块名

定义包的语法：package 包名；

Import 包名.*；包名.类名

Java中不能隔包导入。Java。lang中定义的接口和类使用时不用导包

三、编程题：

1、求1！+2！+3！+…+10!（12分）

public class T1 {

public static void main(String[] args) {

int s = 1;

int sum = 0;

for (int i = 1; i <= 10; i++) {

s *= i;

sum += s;

}

System.out.println("1!+2!+3!...+10!=" + sum);

}

}2、定义一个类，完成一个动态数组，可以存取任意类型的对象，当数组空间全部存进元素，空间应扩大原来的一半。（20分）

import java.util.Arrays;

public class Array_Obj {

private static int count = 0;

private Object[] obj = new Object[5];

public Array_Obj() {

}

public Object[] getObj() {

return obj;

}

public void add(Object obj) {

if (count == this.obj.length) {

objAdd();

}

this.obj[count++] = obj;

}

private void objAdd() {

Object[] temp = obj;

obj = new Object[obj.length + obj.length / 2];

System.arraycopy(temp, 0, obj, 0, count);

}

@Override

public String toString() {

return"T2 [obj=" + Arrays.toString(obj) + "]";

}

}