java期末复习题(二).doc

期末复习题（二）

一、 选择题：
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<b ) x=x+1;
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、在浏览器中执行applet 程序，以下选项中的哪个方法将被最先执行（ ）。
A．init() B．start() C．destroy() D．stop()
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().
21、请说明程序的运行结果
class Test
{
public static void main(String[] args)
{
char myChar='c';
switch(myChar){
default:
case 'a':
System.out.println("a");
break;
case 'b':
System.out.println("b");
break;
}
}
}
22、请写出程序的运行结果
class Tester {
int var;
Tester(double var) {
this.var = (int)var;
}
Tester(int var) {
this("hello");
}
Tester(String s) {
this();
System.out.print (s);
}
Tester() {
System.out.print("goodbye");
}
public static void main(String[] args) {
Tester t = new Tester(5);
}
}
23．java程序的执行过程中用到一套JDK工具，其中javac.exe指( A )
A.    java语言编译器 B.      java字节码解释器
C.    java文档生成器 D.     java类分解器
24．关于Applet和Application，下列说法错误的是（Ｂ）
A．Applet自身不能运行 B．Applet可以嵌在Application中运行
C．Application以main()方法为入口 D．Applet可嵌在浏览器中运行
25．整型数据类型中，需要内存空间最少的是（ Ｄ ）。
A．short B．long C． int D． byte
26．下面的代码段，输出结果是（ Ｂ ）。
int x=015;
System.out.println(x);
A． 015 B．13 C．15 D．编译错误
27．若有以下程序段：
int a=1,b=2,c;
c=1/b*a;
执行后，c的值是（ Ａ ）。
A． 0 B． 0.5 C． 1 D． 2
28．下列关于数组的定义中，不正确的是（ Ｃ ）
A．int[] a=new int[5];
B．int a[]={1,2,3,4};
C．int a[][]= new int[][9];
D．int a[][]={{1}{1,2}{1,2,3}};
29．已知x=5;y=7；经过表达式(x++>5)&&(++y>0)的运算，x和y的值分别是（ Ｄ ）
A．5和7 B． 5和8 C． 6和7 D． 6和8
30．下面描述正确的是： （ Ｄ ）
A．声明变量时必须指定一个类型
B．java认为变量number和Number相同
C．java中唯一的注释方式是“//”
D．源文件中public类可以有0个或多个
31．下面有关抽象类定义合法的是（ Ｄ ）。
A．class Animal{ abstract void growl();}
B．abstract Animal{abstract void growl();}
C．class abstract Animal{abstract void growl();}
D．abstract class Animal{abstract void growl();}
32．根据下面的代码
if (x>0) { System.out.println("第一"); }
else if (x>-3) { System.out.println("第二"); }
else { System.out.println("第三"); }
判断x的取值在（　Ｄ　）范围内时将打印字符串“第二”？
A． x > 0 B． x > -3 C． x <= -3 D．x <= 0 & x > -3
33．要使某个类能被同一个包中的其他类访问，但不能被这个包以外的类访问，则（ Ａ ）。
A．该类不使用任何关键字
B．使用private关键字
C．使用final关键字
D．使用protected关键字
34．以下关于接口不正确的说法是 ( Ｄ ) 。
A．一个类可以实现多个接口类似于多重继承
B．接口没有构造函数和析构函数
C．接口可以继承
D．接口包含的方法既可以有实现，也可以没有实现
35．对于可以独立运行的Java应用程序，下列( Ｄ )说法是正确的。
A．无须main方法
B．必须有两个main方法
C．可以有多个或零个main方法
D．必须有一个main方法
36．以下关于继承的叙述正确的是（ Ａ ）。
A．在Java中类只允许单一继承
B．在Java中一个类只能实现一个接口
C．在Java中一个类不能同时继承一个类和实现一个接口
D．在Java中接口只允许单一继承
37．在浏览器中执行applet 程序，以下选项中的哪个方法将被最先执行（ Ａ ）。
A．init() B．start() C．destroy() D．stop()
38．Java源文件和编译后的文件扩展名分别为（ Ｂ ）。
A．.class 和 .java B．.java和 .class
C．.class 和 .class D．.java 和 .java
39．Java语言不是（ Ｃ ）。
A．高级语言 B．编译型语言
C．结构化设计语言 D．面向对象设计语言
40．Java语言中创建一个对象使用的关键字为 （ Ｃ ）
A．class B．interface C．new D．create
41．设有对象x具有属性a则访问该属性的方法为（ Ｃ ）
A．a.x B．a.x() C．x.a D．x.a()
42．Java中，用package语句说明一个包时，该包的层次结构必须是（ Ｂ ）
A．与文件的结构相同
B．与文件目录的层次相同
C．与文件类型相同
D．与文件大小相同

二、简答题：
1、
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、按以下要求编写程序
(1) 创建一个Rectangle类，添加width和height两个成员变量
(2) 在Rectangle中添加两种方法分别计算矩形的周长和面积
(3) 编写主类Solve，利用Rectangle的对象引用输出一个矩形的周长和面积
class Rectangle{
private int width, height;
public Rectangle(int w,int h){
width=w; height=h;
}
public int zhouchang(){
return 2*(width+height);
}
public int mianji(){
return width*height;
}
}
public class Solve extends Applet{
public static void main(String args[]){
Rectangle a= new Rectangle(80,60);
System.out.println("周长为："+a.zhouchang());
System.out.println ("面积为："+a.mianji());
}
}
3、按以下要求编写程序
(1) 定义Animal接口，接口中声明run() 方法
(2) 定义Bird类和Fish类实现Animal接口
(3) 编写主类AnimalTest，对Bird类和Fish类的run()方法加以引用并输出。
interface Animal {
void run();
}
class Bird implements Animal {
public void run() {
System.out.println("鸟儿在飞...");
}
}
class Fish implements Animal {
public void run() {
System.out.println("鱼儿在游...");
}
}
public class TestAnimal {
public static void main(String[] args) {
Bird bird = new Bird();
bird.run();
Fish fish = new Fish();
fish.run();
}
}
4、给出3门课成绩（例如：语文90，数学80，英语70），编程完成输出3门课的总分、平均分，并根据学生的平均分打出优秀等级：80以上是优秀，70-80是良好，60-70是及格，否则是不及格。
class Studentpj {
public static void main(String[] args) {
int yw=90,yy=70,sx=80;
int s=yw+yy+sx;
double p=(double)s/3;
char a=p>=80?’优’:p>=70?’良’:p>=60?’及’:’不’;
System.out.println(“总成绩为!”+s);
System.out.println(“平均分为!”+p);
System.out.println(“优秀等级为!”+a);
}
}
5、设计类A和A的派生类B，要求：
1）A有两个数据成员a和b（都为int型）；B中继承了A中的a和b，又定义了自己的数据成员c（int型）。
2）为A添加含有两个参数的构造方法，对a和b初始化。
3）为B添加含有一个参数的构造方法，对c初始化。
4）完成主控方法，在主控方法中用B e1=new B()创建对象，把a、b、c分别初始化成3、4、5，最后输出它们的和。
class A{
int a,b;
A(int x,int y){
a=x;
b=y;
}
}
class B extends A{
int c;
B(int x,int y,int z){
super(x,y);
c=z;
}
}
public class D{
public static void main(String args[]){
B e=new B(3,4,5);
System.out.println("sum="+(e.a+e.b+e.c));
}
}

5、编写一个求面积的程序，程序可以给定必要数据后，输出矩形、圆的面积，面积可以用抽象类来实现或接口实现。矩形的基本信息是高度和宽度，圆的基本信息是半径。

interface A{
public void zhouchang(double a,double b);
public void mianji(double x, double y);
}
class Juxing implements A{
double s,c;
public void zhouchang(double a,double b) {
c=2*(a+b);
System.out.println("矩形周长="+c);
}
public void mianji(double a,double b){
s=a*b;
System.out.println("矩形面积="+s);
}
}
class Yuan implements A{
double s, c;
public void zhouchang(double r,double m) {
c=3.14*2*r;
System.out.println("圆周长="+c);
}
public void mianji(double r,double m){
s=3.14d*r*r;
System.out.println("圆面积="+s);
}
}
public class F {
public static void main(String[] args) {
Juxing j=new Juxing(); Yuan y=new Yuan();
j.zhouchang(2,3);
j.mianji(2,3);
y.zhouchang(4,1);
y.mianji(4,1);
}
}
11