一、单项选择题
1、如下哪个是Java中的标识符（）
A、public B、super C、3number D、width 2、如下哪个是Java中的标识符( )
A、fieldname B、super C、3number D、#number 3、已知如下定义：String s = \下面哪个语句不是合法的( )
A、s += \ C、int len = s.length;
B、s = s + 100; D、String t = s + “abc”;
11、this和super（ ）：
A、都可以用在main()方法中B、都是指一个内存地址 C、意义相同 D、不能用在main()方法中 12、关于接口哪个正确？（ ） A、接口和抽象类是同一回事 B．一个类只能实现一个接口 C．接口间不能有继承关系
D．实现一个接口必须实现接口的所有方法 13、关于静态成员下面说法错误的是（ ） A、静态成员是最终成员变量 4、如下哪个是Java中有效的关键字()
A、name
B、hello
C、false
D、good
5、定义一个类，必须使用的关键字是( )
A、public
B、class C、interface D、static
6、定义一个接口必须使用的关键字是（ ）
A、public
B、class C、interface D、static
7、下列哪一个import命令可以使我们在程序中创建输入/输出流对象（）
A、import java.sql.*; B、import java.util.*; C、import java.io.*;
D、import java.net.*;
8、关于对象成员占用内存的说法哪个正确？（ ） A．同一个类的对象使用不同的内存段，但静态成员共享相同的内存空间
B、同一个类的对象共用同一段内存 C．对象的方法不占用内存 D．以上都不对
9、下面关于子类和父类构造函数描述正确的是（ ） A、子类必须通过super关键字调用父类无参的构造函数
B、子类必须通过this关键字调用父类无参的构造函数
C、调用父类的构造函数语句必须出现在子类构造函数的第一行
D、如果子类调用了自己有参的构造函数，就不能调用父类的构造函数 10、抽象方法（ ）
A、可以有方法体 B、是没有方法体的方法 C、可以出现在非抽象类中 D、抽象类中的方法都是抽象方法
B、静态成员属于类成员
C、定义静态成员使用的关键字是static D、静态成员必须创建对象时才能使用 14、以下关于继承的叙述正确的是（ ）。 A、在Java中一个类只能实现一个接口 B、在Java中类只允许单一继承
C、在Java中一个类不能同时继承一个类和实现一个接口
D、在Java中接口只允许单一继承
15、要使某个类能被同一个包中的其他类访问，但不能被这个包以外的类访问，则（ ）
A．让该类不使用任何关键字 B．使用private关键字 C．使用final关键字
D．使用protected关键字
16、下列哪个代码替换程序中的【代码】不会导致编译错误? BCD
(A)protected int getNumber(){return 100；} (B)int getNumber(){return 100；}
(C)public int getNumber(){return 100；} (D)int getNumber(){return ’a’+’b’；}
interface c1ass AAA{
abstract int getNumber(); }
class BBB implements AAA {
【代码】 }
17、void的含义：（ ）
A．没有意义 B． 方法体为空
C．方法没有返回值
D. 定义方法时必须使用
18、覆盖与重载的关系是 （ ）
A、覆盖方法可以不同名，而重载方法必须同名 B．覆盖只有发生在父类与子类之间，而重载可以发生在同一个类中
C．final修饰的方法可以被覆盖，但不能被重载 }
public class A{
public static void main(String args[]){
Tom tom=new Tom(); tom.x=22; //【代码l】 tom.y=33; //【代码2】 D．覆盖与重载是同一回事
19、下列类声明错误的有?
(A)final abstract class A (B)final class A (C)protected class A (D)public class A
20、下列E类的类体中哪个【代码】是错误的?
class E{
float x; //【代码1】
long y=(int)x; //【代码2】 public void f(int n){
double m; //【代码3】 double t=n; //【代码4】 } }
21、下列A类的类体中哪些【代码】是错误的?
class A{
int x=100; //【代码1】 static long y;//【代码2】 y=200; //【代码3】 public void f(){ y=300;//【代码4】 }
public static void g(){
x=-23; //【代码5】 } }
22、下列A类的类体中哪些【代码】是错误的?
class Tom {
private int x=120; protected int y=20; int z=11;
private void f(){
x=200;
System.out.println(x); }
void g(){
x=200;
System.out.println(x); }
tom.z=55; //【代码3】 tom.f(); //【代码4】 tom.g(); //【代码5】 }
}
23、下列叙述哪些是正确的? (A)final类不可以有子类。
(B)abstract类中只可以有abstract方法。
(C)abstract类中可以有非abstract方法，但该方法不可以用final修饰。
(D)不可以同时用final和abstract修饰一个方法。 24、下列哪个代码替换程序中的【代码】会导致编译错误?
(A)protected int getNumber(){return 100；} (B)int getNumber(){return 100；}
(C)public int getNumber(){return 100；} (D)public int getNumber(){return 'a'+'b'；}
abstract class AAA{
abstract protected int getNumber (); }
class BBB extends AAA{
【代码】 }
25、下列哪个代码替换程序中的【代码】不会导致编译错误?
(A)protected long getNumber(){return 20L；} (B)public byte getNurnber（）{return 10；} (C)public int getNumber（）{return(byte)lO；} (D)public char getNumber（）{return 'A’；}
abstract class AAA{
abstract protected int getNumber()； }
class BBB extends AAA {
【代码】
}
二、填空题
1、如果将类MyClass声明为public，它的文件名称必须是（MyClass.java）才能正常编译。 2、Java程序中的单行注释符是（ // ），多行注释符是（ /* */ ）。 3、Java中布尔类型的常量有两种，它们是（true）和（false）。
4、Java中用于定义小数的关键字有两个：（float） 和 （double），后者精度高于前者。
5、Java中用于两个数相等比较的运算符是：（==），用于不相等比较的运算符是（<>）。 6、在Java中定义一个字符串类型的变量str的语句是：（String str;） ，定义一个具有10个元素的整型数组a的语句是：（int [] arr = new int[10];） 。
7、导入mypackage包中的所类的命令是（ import mypackage.*; ）。 8、当声明一个数组int arr[] = new int[5]; 时，这代表这个数组所保存的变量类型是（int），数组名是 （arr），数组的大小为（5），数组元素下标的使用范围是（0到4）。
9、假设x=13，y=4，则表达式x%y != 0的值是（true），其数据类型是（boolean）。 10、异常处理是由（try）、（catch）和finally块三个关键所组成的程序块。
11、导入mypackage包中的类myclass的命令是（ import mypackage.myclass; ）。 12、使用命令行敲入javac命令，其含义是（ 编译java文件，得到字节码文件）。 13．定义类的保留字是( class)，定义接口的保留字是( interface )。 14．构造方法是一种特殊的成员方法，构造方法名与( 类名) 相同。 15．Java语言只允许单继承，指每个类只能有一个 ( 父类 )。
16．Java源程序的扩展名是( .java)，经过编译后的程序的扩展名是（.class）。
17、如果将类MyClass声明为public，它的文件名称必须是（Myclass.java）才能正常编译。
三、程序阅读题
1、以下程序的输出结果为_ Peter is 17 years old!___。 public class Person { String name; int age;
public Person(String name, int age) { this.name = name; this.age = age; }
public static void main(String[] args) {
Person c = new Person(\, 17); System.out.println(c.name + \is \ + c.age + \); } }
2、以下程序的输出结果为__课程号:101 课程名:ASP 学分:3___。
public class Course {
private String cNumber; private String cName; private int cUnit;
public Course(String number, String name, int unit) {
cNumber = number; cName = name; cUnit = unit; }
public void printCourseInfo() { System.out.println(\课程号:\ + cNumber + \课程名:\ + cName + \学分:\ + cUnit); } }
class CourseTest { public static void main(String[] args) {
Course c;
c = new Course(\, \, 3); c.printCourseInfo(); } }
3、以下程序的输出结果为__汤姆猫体重：20.0斤___。 public class Tom {
private float weight;
private static String name;
public void setWeight(float weight) { this.weight = weight; }
private void out() {
System.out.println(name + \体重：\ + weight + \斤\); }
public static void main(String[] args) { Tom.name = \汤姆猫\; Tom cat = new Tom(); cat.setWeight(20); cat.out();
}
}
4、以下程序的输出结果_姓名:Tom 年龄:15 家庭住址:金水区 电话:66123456 学校：九中_。 public class Father {
String name, address, tel; int age;
public Father(String name, int age) { this.name = name; this.age = age; }
void out() { System.out.print(\姓名:\ + name); System.out.print(\年龄:\ + age); }
void outOther() { System.out.print(\家庭住址:\ + address);
System.out.print(\电话:\ + tel); } }
class Son extends Father { String school;
public Son(String name, int age) { super(name, age); }
void out() { super.out();
super.outOther();
System.out.println(\学校：\ + school); }
public static void main(String args[]) public void print() { super.print();
System.out.println(\ } }
//增加的测试代码
public class XT003302 {
public static void main(String[] args) { Child c = new Child(1,2,3,4); c.print(); {
Son son = new Son(\, 15); son.address = \金水区\; son.school = \九中\; son.tel = \; son.out();
}
}
5、下列程序的运行结果是__12345____。 public class MyClass {
int a[] = { 1, 2, 3, 4, 5 }; void out() {
for (int j = 0; j < a.length; j++) System.out.print(a[j] + \); }
public static void main(String[] args) {
MyClass my = new MyClass(); my.out(); }
}
6．运行下面的程序，输出并记录结果。 class Father{
private int f1,f2;
public Father(int f1,int f2) { this.f1=f1;this.f2=f2; }
public void print() {
System.out.println(\ } }
class Child extends Father { private int c1,c2;
public Child(int f1,int f2,int c1,int c2) { super(f1,f2);
this.c1=c1;this.c2=c2; }
} } 输出:
f1=1 f2=2 c1=3 c2=4
7.请说出A类中System.out.println的输出结果。
class B{
int x=100,y=200;
public void setX(int x){
x=x; }
public void setY(int y){
this.y=y; }
public int getXYSum(){
return x+y; } }
public class A{
public static void main(String args[]){
B b=new B(); b.setX(-100); b.setY(-200);
System.out.println(\m()); } }
sum=-100
8.请说出A类中System.out.println的输出结果。
public class A{
public static void main(String args[]){
10.请说出A类中System.out.println的输出结果。
class B{
int n;
B b=new B(20); add(b);
System.out.println(b.intValue()); }
public static void add(B m){
int t=777;
m.setIntValue(t); } }
class B {
int n; B(int n){
this.n=n; }
public void setIntValue(int n){
this.n=n; }
int intValue(){
return n; } } 777
9.请说出A类中System.out.println的输出结果。
public class A{
public static void main(String args[]){
Integer integer=new Integer(20); add(integer);
System.out.println(integer.intValue()); }
public static void add(Integer m){
int t=777;
m=new Integer(t); } } 20
static int sum=0; void setN(int n){
this.n=n; }
int getSum(){
for(int i=1;i<=n;i++)
sum=sum+i; return sum;
} }
public class A{
public static void main(String args[]){
B b1=new B(),b2=new B(); b1.setN(3); b2.setN(5);
int s1=b1.getSum(); int s2=b2.getSum();
System.out.println(s1+s2); } } 21
11．请说出E类中System.out.println的输出结果。 class A {
double f(double x，float y){
return x+y; }
double f(float x，float y){
return x*y; } }
public class E{
public static void main(String args[]){
A a=new A();
System.out.println(\，10))；
System.out.println(\，10.0F))； } }
**100.0 ##20.0
12．请说出E类中System.out.println的输出结果。
class A{
double f(double x,double y){
return x+y; } }
class B extends A{//重载
double f(int x，int y){
return x*y； } }
public class E{
public static void main(String args[]){
B b=new B()；
System.out.println(b.f(3，5))； System.out.println(b.f(3.0，5.0)); }
}
15.0 8.0
13．请说出E类中System.out.println的输出结果。
c1ass A{
double f(double x，double y){
return x+y; }
static int g(int n){
return n*n; } }
class B extends A{
double f(double x，double y){//重写
double m=super.f(x，y)； return m+x*y； }
static int g(int n){
int m=A.g(n); return m+n； } }
public class E{
public static void main(String args[]){
B b=new B()；
System.out.println(b.f(10.0，8.0))；System.out.println(b.g(3))； } }
98.0 12 14.请说出E类中System.out.printf的输出结果。
interface Computer{
int computer(int x，int y); }
abstract class AA{
int computer(int x，int y){
return x-y; } }
class B extends AA implements Computer{
public int computer(int x，int y){
return x+y; } }
public class E{
public static void main(String args[]){
Computer com=new B(); AA a=new B();
System.out.printf(\，com.computer(12，10));
System.out.printf(\，a.computer(15，5)); }
22 20
四、简答题
1．如果在D:\\MyJavaFile目录下有一个文件FirstJavaProgram.Java，写出在JDK环境下，此程序的运行过程。
答：运行过程：先切换到D:\\MyJavaFile目录，然后依次执行：
（1）javac FirstJavaProgram.Java （2）java FirstJavaProgram.class
2．什么叫面向对象编程？什么是对象？什么是类？
面向对象编程(Object-Oriented 6．普通数据类型参数和引用数据类型在方法中的传递有什么不同？
普通数据类型参数的传递采用值传递，在方法中对变量的改变不会影响到主程序的同名变量，引用数据类型在方法中的传递采用地址传递，在方法中对变量的改变使主程序的同名变量发生改变。
7．什么是构造方法？构造方法有什么特点？
构造方法是一种特殊的方法，当用new命令每生成一个实例时，构造方法都会自动执行一次，而无须用户Programming ,OPP)是一套概念和想法,它与面向过程的编程方法相对应，是一种利用计算机程序来描述实际问题的思路,也是一种直观,效率更高的解决问题的方法。面向对象的程序设计方法按照现实世界的特点来管理复杂的事物,把它们抽象为对象,具有自己的状态和行为,通过对消息的反应来完成一定的任务。
对象就是变量和相关的方法的集合,其中变量表明对象的状态,方法表明对象所具有的行为，一个对象的变量构成这个对象的核心，包围在它外面的方法使这个对象和其它对象分离开来。
类是对一组具有相同特征的对象的抽象描述，所有这些对象都是这个类的实例。在程序设计语言中，类是一种数据类型，而对象是该类型的变量，变量名即是某个具体对象的标识名。
3．类的修饰符包括哪些？各起什么作用？
包括访问控制符（表示被访问权限）、抽象类说明符abstract（说明是否是抽象类）、最终类说明符final（表示是否是最终类）。
4．什么是抽象类？什么是抽象方法？抽象方法与普通方法有什么不同？
以abstract作为关键字，如果有的话，应该放在访问控制符后面，表示这个类是个抽象类。抽象类中至少包含一个抽象方法，抽象方法是只声明了方法名和参数而没有定义方法体的特殊方法。抽象类不能直接产生实例化一个对象，它只能被继承。
5．父类与子类是怎样建立关联的？如果父类和子类中都有一个同名的方法，在程序中调用这个方法，应该用什么关键字来区分？
父类与子类是通过继承和派生建立关联的，父类可以派生出子类，可以被子类继续，子类可以继续父类的属性和方法。
如果父类和子类中都有一个同名的方法，通过关键字super和this区分，super表示调用父类的方法，而this表示调用的是子类的方法。
手工引用。
构造方法的特征：具有与类相同的名称，不含返回类型，不能在方法中用return语句返回一个值。 在类实例化时，它会由系统自动调用
8．接口与类有什么不同？与抽象方法存在什么样的关系？
接口（interface）是一种特殊的类，接口是方法定义（即抽象方法）和常量值的集合，只包含常量和方法的定义，没有变量和方法的实现。使用接口的目的是解决Java语言中不支持多重继承的缺陷。
接口中包含若干抽象方法，没有具体的方法。
9、什么是继承？
答：通过必要的说明能够实现某个类无需重新定义就拥有另一个类的某些属性和方法，并把这种关系称为继承，先定义的类称为父类，后定义的类称为子类，并且允许多层的继承关系。
10、请简述重载和重写的区别？ 答：方法的重写Overriding和重载Overloading是Java多态性的不同表现。
重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。
如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。
如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。
五、程序设计题
1、按以下要求编写程序
(1) 创建一个Rectangle类，添加width和height两个成员变量
(2) 在Rectangle中添加两种方法分别计算矩形的周长和面积
(3) 编程利用Rectangle输出一个矩形的周长和面积 解答：
public class Rectangle { float width, height;
public Rectangle(float width, float height) {
this.width = width; this.height = height; }
public float getLength(){ return (this.width + this.height) * 2; }
public float getArea(){
return this.width * this.height; }
public static void main(String [] args) {
Rectangle rect = new Rectangle(10, 20);
System.out.println(\周长是：\ + rect.getLength());
System.out.println(\面积是：\ + rect.getArea()); }
}
2．定义一个日期类，包括年、月、日三个属性和一个方法，用于判断是不是闰年。然后实例化两个对象，今年和明年，并分别给它们赋值。 class DateClass { int year,month,day; boolean isLeapYear(){ if
(((year%4==0)||(year0==0))&&(year@0!=0)) return true; else
return false; } }
public class XT {
public static void main(String[] args) { DateClass thisYear,nextYear;
thisYear = new DateClass(); thisYear.year=2005; thisYear.month=4; thisYear.day=5;
nextYear = new DateClass(); nextYear.year=2006; nextYear.month=10; nextYear.day=26;
System.out.println(thisYear.isLeapYear()); System.out.println(nextYear.isLeapYear()); } }
3．编写一个程序实现方法的重载。 class PassCheck { String s,ok;
PassCheck(String s) {
System.out.println(\您设置的字符串是：\ }
PassCheck(String s,String ok){ if (!(s.equals(ok)))
System.out.println(\您设置的字符串有错，正确的应该是：\ }
public class XT003202 {
public static void main(String args[]){ new PassCheck(\
new PassCheck(\ } }
4.编写一个含有抽象方法和一个抽象类的程序。 abstract class ObjectAccess{ //抽象类 int num=0; Object access[]=new Object[20]; abstract void inputToArray(Object o); //抽象方法1 abstract Object outputFromArray(); //抽象方法2 }
5、编写一个程序实现抽象类。
interface Speed { //定义接口
public int Speed(int x,int y);//定义抽象抽象方法 }
class Bus implements Speed { //继承接口
public int Speed(int x,int y) { //实现抽象方法
return x+y; } }
public class XT004201 {
public static void main(String args[]) { int a=10,b=20;
Speed tool=new Bus(); //实例化
System.out.println(\汽车的速度是：\ //调用方法
} }
6、写出利用接口实现多重继承的示意性程序。
interface interface1 {
void method1(); //定义抽象方法method1 }
interface interface2 {
void method2(); //定义抽象方法method2 }
interface interface3 extends interface1,interface2 { void method3(); //定义抽象方法method3 }
7、编写一个程序，实现包的建立和包的引入。
//建立包的程序：程序名Farmer.java package mypackage; public class Farmer { public String name; public String sex; public int age;
public Farmer(String xm,String xb,int nl){ name=xm; sex=xb; age=nl; } }
//调用包的程序：XT004203.java
import mypackage.Farmer; public class XT004203 {
public static void main(String args[]) {
Farmer manager=new Farmer(\李国军\男\
System.out.println(\姓名：\ System.out.println(\性别：\ System.out.println(\年龄：\ } }
8、按以下要求编写程序
(1) 编写Animal接口，接口中声明run() 方法 (2) 定义Bird类和Fish类实现Animal接口 (3) 编写Bird类和Fish类的测试程序，并调用其中的run()方法
解答：
public 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(); } }
9．编写一个Java Application程序，输入姓名、性别、年龄后系统将用户输入的信息存入一个Vector类对象，10. 按以下要求编写程序
然后将这些信息显示出来。 import java.util.*; import java.io.*;
class People { String name; String sex; int age; }
public class XT004302 {
public static void main(String[] args) throws java.io.IOException {
People p = new People(); Vector v = new Vector();
BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); do {
System.out.print(\ p.name = in.readLine();
System.out.print(\ : \ p.sex = in.readLine();
System.out.print(\ : \ p.age = Integer.parseInt(in.readLine()); v.addElement(p);
System.out.println(\ }while ((char)System.in.read()=='Y' ) ; for (int i=0;i System.out.println(\+\ sex=\p.sex +\ age=\ } } } (1) 编写抽象Person类，类中有保护访问权限的字符串类型属性 name，包含抽象方法getname（）。 （2）编写WORK接口，接口中声明working( ) 方法。 (3) 定义Teacher类，从Person类中继承，实现getname（）方法，返回name属性；实现WORK接口，在working（）方法中输出“正在上课！”。此外，添加两个构造函数，一个带参数，一个不带参数，均能给属性name赋值；添加show（），输出“我是一名老师！”。 （4）定义Student类从Person类中继承，实现getname（）方法，返回name属性；实现WORK接口，在working（）方法中输出“正在做作业！”。此外，添加两个构造函数，一个带参数，一个不带参数，均能给属性name赋值；添加show（），输出“我是一名学生！”。 (5) 编写Teacher类的测试程序，建立1个对象，通过参数对它初始化，测试类中的所有方法。