java复习题

java复习题

一、 判断题（每题1分，共20分）从中选择20道

1. Java中，一个类重载的构造函数之间不能直接通过构造函数名调用。 T
2. 一个Java源程序中如果有多个类，则这些类都可以用public修饰。 F
3. 如果构造方法中有this调用，则它必须是构造函数中的第一个行语句。 T
4. final修饰的类不能被继承。 T
5. Java的源代码中定义几个类，编译结果就生成几个以.class为后缀的字节码文件。 T
6. 每个类都只能有一个构造方法。 F
7. Java中数组的元素只能是简单数据类型的。 F
8. 一个类只能有一个父类，但一个接口可以有一个以上的父接口。 T
9. 用new来创建一个类的实例，即”对象”。 T
10. 能被java.exe成功运行的java class文件必须有main()方法 T
11. abstract不能和final并列修饰同一个类； T
12. 一个方法使用final修饰，则该方法所在的类不能被继承； F
13. 含有abstract方法的类一定是抽象类； T
14. 抽象类中必须都是abstract方法。F
15. 类的定义中必须编写构造方法，否则编译会报错误。F
16. 与类名相同，返回值为void的方法是构造方法。F
17. static定义的属性变量，既可以用类名来引用，也可以用对象名来引用。T
18. 不论try块中是否发生了异常，是否执行过catch语句，如果有finally语句，不一定要执行finally语句。 F
19. Java中，java.lang.Object类是所有类的父类。 T
20. 接口中的方法都是抽象方法。 T
21. 关键字this表示的是当前对象。 T
22. 一个类的属性既可以是基本类型的变量，也可以是对象变量 T
23. 子类可以访问父类中定义的私有属性。 F
24. 抽象类可以被实例化。 F
25. 如果一个非抽象类B继承了抽象类A，则B必须实现类A中定义的抽象方法。 T
26. 父类中定义的所有属性，在子类中都可以直接使用。 F
27. 面向对象的基本特征包括继承、封装、多态。 T
28. Java中，数组对象都有一个属性length。 T
29. 一个类中定义两个方法，名字相同，参数相同，返回值不同，他们是重载方法。 F
30. 创建一个包应使用import语句。 F
31. 构造方法的方法名与类名相同，若类中没有定义任何的构造方法，则运行时系统会自动为该类生成一个（默认构造）方法。 T
32. 静态变量在内存中只有一个，被该类的所有对象共享。 T
33. 在运行时，由java解释器自动引入，而不用import语句引入的包是java.lang。T
34. 在Java中，字符串和数组是作为对象出现的。 T
35. Java不允许用户自定义异常。 F
36. 运行时异常必须在代码中处理。F
37. 构造方法不可以重载，但可以继承。 F
38. 在运行时，由java解释器自动引入，而不用import语句引入的包是java.util。 F
39. 创建对象时系统将调用适当的构造方法给对象初始化。 T
40. Java不允许子类覆盖父类中的成员方法。 F
41. 抽象类不能有构造方法。F
42. 构造方法没有返回值，且不用void声明。 T
    二、 关键字填空（每小题1分，共15分）
    在下列选项中选择正确的关键字前的编号填空：

1. abstract 2) boolean 3) catch 4) class 5) char 6) double 7) extends 8) final 9) finally 10) implements 11) import 12) instanceof 13) interface 14) new 15) package 16) private 17) protected 18) public 19) static 20) super 21) switch 22) this 23) throw 24) try
   （1）声明类（ ）。
   （2）表明抽象类或者抽象方法（ ）。
   （3）创建新实例对象（ ）。
   （4）声明继承关系（ ）。
   （5）表明当前对象的引用或者当前类型的构造方法（ ）。
   （6）表明当前对象的父类型的引用或者父类型的构造方法（ ）
   （7）表示静态属性（ ）
   （8）最终的，可以修饰属性、方法、类的关键字（ ）
   （9）布尔类型（ ）
   （10）定义接口（ ）
   （11）实现接口（ ）
   （12）修饰符，表示私有模式（ ）
   （13）引入包（ ）
   （14）尝试一个可能抛出异常的程序块（ ）
   （15）抛出一个异常（ ）
   答案：
   题号 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
   答案 4 1 14 7 22 20 19 8 2 13 10 16 11 24 23

三、阅读程序写结果（第1-2题2分，第3-9题每3分，共25分）
（1）
public class Test { // 简单，字符串连接
public static void main(String[] args) {
int x = 2;
char ch = ‘A’;
System.out.println(“x=” + x + “,ch=” + ch);
}
}
运行结果: x=2,ch=A
(2)//方法调用
public class TestA {
public static void arrays(int[] a) {
for(int i =0; i<a.length-1; i++) {
int k =i;
for(int j =i+1; j<a.length; j++) {
if(a[j]<a[k]) {
k = j;
}
}
int t = a[i];
a[i]=a[k];
a[k]=t;
}
}

public static void main(String[] args) {
	int[] arr = {5,8,3,9,6};
	arrays(arr);

	for(int i =0; i<arr.length; i++) {
		System.out.println(arr[i]+" ");
	}
}

}
运行结果：
3
5
6
8
9
(3)//重载
public class Overload
{
public void test()
{
System.out.println(“无参数”);
}
public void test(String msg)
{
System.out.println("重载的test方法 " + msg);
}
public static void main(String[] args)
{
Overload t = new Overload();
t.test(“hello”);
}
}
运行结果：
重载的test方法 hello

(4)//静态
class User {
static int count=0;
long ID;
public User(){
count++;
ID=30802000+count;
System.out.println(“你是第”+count+“个用户”);
System.out.println(“你的ID是”+ID);
}
}
public class TestUser{
public static void main(String[] args) {
User p=new User();
User q=new User();
}
}

运行结果：
你是第1个用户
你的ID是30802001
你是第2个用户
你的ID是30802002
(5)class FatherClass{//父子类构造方法的调用次序
public FatherClass() {
System.out.println(“创建父类”);
}
}
class ChildClass extends FatherClass {
public ChildClass() {
System.out.println(“创建子类”);
}
}
public class Test {
public static void main(String[] args){
FatherClass fc = new ChildClass();
}
}
运行结果为:
创建父类
创建子类
（因为：子类的构造器一定会先调用父类构造器）

（6） public void test() { //异常
try {
method();
System.out.println(“Hello World”);
}
catch (ArrayIndexOutOfBoundsException e) {
System.out.println(“Exception0”);
}
catch(Exception e){
System.out.println(“Exception1”);
}
finally{
System.out.println(“Thank you!”);
}
}
如果函数method运行出现ArrayIndexOutOfBoundsException异常，运行结果：
Exception0
Thank you!

（7）//多态
class Parent{
public void display(){ System.out.println(“我是父类”);}
}
class Child extends Parent{
public void display(){ System.out.println(“我是子类”);}

}
public class Test{
public static void main(String[] args){
Child c = new Child();
c.display();
Parent p = new Child();
p.display();
}
}
运行结果：
我是子类
我是子类

（8）//this,super的调用
class A {
A(){
System.out.println(“A（）”);
}
A(int i){
this();
System.out.println(“A(i)”);
}
} //class A
class B extends A {
B(){
super();
System.out.println(“B（）”);
}
}//class B
public class Test {
public static void main(String[] args){
A a = new A(0);
B b = new B();
}
}
运行结果：
A（）
A(i)
A（）
B（）

(9) //字符串
public class TestString {
public static void main(String[] args) {
String id = “132321199501180025”;
int y = Integer.parseInt(id.substring(6,10));

	if((y%4 == 0 && y%100 != 0 )||(y%400 == 0)) {
		System.out.println("  a leap year");
	}
	else {
		System.out.println("NO");
	}				    

}
}
运行结果 ：NO

四、编程题（5题，共40分）
1、顺序结构（调用方法）（1道，10分）：
main方法中有两个整数，为这两个整数赋任意初值，调用方法求这两个整数的和，并显示。
【答案】
public class Test {
public static int getHe(int a,int b){
return a+b;
}
public static void main(String[] args) {
int a = 20;
int b = 16;
int sum = getHe(a,b);
System.out.println(a + “+” + b + “=”+sum);
}
}

2、数组调用方法（1道，9分）
main 方法中定义一个10个元素的整数数组，数组元素的值定义时进行初始化，调用方法获得该数组中的偶数个数。
【答案】
public class Test {
public static int countEven(int[] a) {
int count = 0;
for (int i = 0; i < a.length; i++) {
if (a[i] % 2 == 0) {
count++;
}
}
return count;
}

public static void main(String[] args) {
	int[] a = { 10, 2, 1, 8, 22, 33, 55, 111, 11, 9 };
	int count = countEven(a);
	System.out.println("偶数个数为" + count);
}

}
3. 简单对象的构造.(8)
编写一个学生类，属性：学号（整数类型），姓名,属性均为私有的.
（1） 编写无参构造方法和带参数的构造方法；
（2） 姓名属性的set，get方法。
（3） 学号属性的set get方法。
答案：
public class Student {
private int no;
private String name;

public Student(){		
}
public Student(int no, String name) {
	super();
	this.no = no;
	this.name = name;
}
public int getNo() {
	return no;
}

public void setNo(int no) {
	this.no = no;
}
public String getName() {
	return name;
}
public void setName(String name) {
	this.name = name;
}	

}
4. 已知类之间的关系(8分)
（1）图形（Shape）类为抽象类，包含计算体积的方法：
public abstract double volume();
（2） 接口 Fill,包含根据传递的颜色参数填充的方法
public abstract void fillColor(String color);
(3）圆柱体类Cylynder继承自Shape，实现Fill接口,属性包括底半径和高，均为double,设置为私有的，要求完成构造方法，省略set get方法，覆盖体积方法，实现fillColor方法，方法中打印“我用**填充”，**代表传递进来的参数。
(4) 编写测试类：
声明Shape类型引用，创建1个圆柱体对象，底部半径和高从键盘录入，求圆柱体的体积并打印，调用填充方法。

参考答案：
import java.util.Scanner;
abstract class Shape {
public static final double PI = 3.14;
public abstract double volume();
}
interface Fill {
public abstract void fillColor(String color);
}
class Cylinder extends Shape implements Fill {
double r;
double h;

public Cylinder() {
}
public Cylinder(double r, double h) {
	this.r = r;
	this.h = h;
}
public double volume() {
	return PI * r * r * h;
}
public void fillColor(String color) {
	System.out.println("我用" + color + "填充");
}

}
public class TestShape {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println(“请输入半径”);
double r = sc.nextDouble();
System.out.println(“请输入高”);
Double h = sc.nextDouble();

	Shape s = new Cylinder(r,h);
	System.out.println("体积为"+s.volume());
    ((Fill)s).fillColor("红色");
}

}