Java课后习题答案.doc

第1 章 Java 概述
【1】为什么说Java 的运行与计算机硬件平台无关？
[解答]：Java 编译器能够产生一种与计算机体系结构无关的字节指令(Byte Code)，只要安装了 Java 虚拟机，Java 就可以在相应的处理机上执行。利用Java 虚拟机就可以把Java 字节码程序跟具体的操作系统以与硬件平台分隔开来。
【2】Java 有什么特点？
[解答]：Java 的特点有：(1) 简单性；(2) 面向对象；(3) 跨平台性；(4) 健壮性；(5) 安全性；(6) 可移植性；(7) 多线程性；(8) 动态性。
【3】试述Java 开发环境的建立过程。
[解答]：Java 开发环境的建立过程如下：
1．JDK的下载与安装：从下载最新版的JDK，单击下载后的文件即出现安装界面；在此界面中打击“next”按钮即可；
2．JDK 的配置：安装好JDK 后，设安装路径为c:\jdk1.5；还需要在环境变量中进行对应的配置。下面以Windows 操作系统为例来进行配置。
1) 设置JAVA_HOME 环境变量：在桌面上用鼠标右键单击“我的电脑”，依次选择“属性”、“高级”、“环境变量”选项，新建一个系统变量，名称为JAVA_HOME，值为c:\jdk1.5；2) 设置CLASSPATH 环境变量， 设置方法与JAVA_HOME 一样， 其值为c:\jdk1.5\lib\tools.jar;. ；
3) 更新PATH 环境变量的值，编辑PATH 系统变量，在最后添加c:\jdk1.5\bin;. 。
【4】什么是Java API? 它提供的核心包的主要功能是什么？
[解答]：Java API 就是Java 所提供的标准类库，它把程序设计所需要的常用的方法与接口分类封装成包。在 Java API 中主要包括核心java 包、javax 扩展包与org 扩展包等。核心java包中封装了程序设计所需要的主要应用类。
【5】如何编写与运行Java 应用程序？
[解答]：Java 应用程序的编写与运行过程：
1．建立Java 源文件：首先创建Java 的源代码，即建立一个文本文档，包括有符合Java 规范的语句。
2．编译源文件：“编译”就是将一个源代码文件翻译成计算机可以理解与处理的格式的过程。Java 源程序编译后会生成一个字节码文件，即带扩展名class 的文件。Java 字节码文件中包含的使Java 解释程序将要执行的指令码。
3．执行字节码文件：通过Java 虚拟机运行字节码文件。
【6】为什么要为程序添加注释，在Java 程序中如何为程序添加注释？
[解答]：注释是程序中的说明性文字，是程序的非执行部分。它的作用是为程序添加说明，增加程序的可读性。
Java 使用以下二种方式对程序进行注释：
1．“//”符号，它表示从“//”符号开始到此行的末尾位置都作为注释。
2．“/*．．．*/”符号，它表示从“/*”开始到“*/”结束的部分都作为注释部分，可以使多行注释。
【7】Java 工具集中的javac、java、appletviewer 各有什么作用？
[解答]：javac 的作用：它是Java 编译器，用于将Java 源程序编译成字节码文件；
java 的作用：它是Java 解释器，用于解释执行Java 字节码文件；
appletviewer 的作用：Applet 程序浏览器，用于测试与运行Applet 程序。
【8】如何建立与运行Java Applet 程序？
[解答]：Java Applet 程序的建立与运行过程：
1．建立Java 源文件：首先创建Java 的源代码，即建立一个文本文档，包括有符合Java 规范的语句。
2．编译源文件：将Java 源文件编译成．Class 的字节码文件，然后再将字节码文件嵌入到一个HTML 文件中。
3．利用浏览器解释执行html 文件。
第2 章 Java 基础
【1】什么是数据类型？为什么要将数据划分为不同的数据类型？
[解答]：Java 是一门强类型语言。数据类型是用来区分不同的数据；由于数据在存储时所需要的容量各不相同，不同的数据就必须要分配不同大小的内存空间来存储，所有就要将数据划分成不同的数据类型。
【2】Java 中有哪些数据类型？
[解答]：Java 中有8 种基本数据类型：字节型(byte)，短整型(short)，整型(int)，长整型(long)，字符型(char)，单精度型(float)，双精度型(double)，布尔型(boolean)。
【3】声明变量的作用是什么？
[解答]：变量时一个数据存储空间的表示，将数据指定给变量，就是将数据存储至对应的内存空间，调用变量，就是将对应的内存空间的数据取出来使用。声明变量就是申请一个内存空间。
【4】若x=4,y=2,计算z 值：
(1) z=x&y
(2) z=x|y
(3) z=x^y
(4) z=x>>y
(5) z= ~ x
(6) z= x<< y
(7) z= x>>> y
[解答]：
public class Test_4 {
public static void main(String[] args) {
int x = 4, y = 2, z; //初始化x,y,z
z = x & y; //求z=x&y;即x 与y 的值
System.out.println("4_1:"+z);
z = x | y; //求z=x|y;即x 或y 的值
System.out.println("4_2:"+z);
z = x ^ y; //求z=x^y;即x 异或y 的值
System.out.println("4_3:"+z);
z = x >> y; //求z=x>>y;即x 右移y 位的值
System.out.println("4_4:"+z);
z = ~x; //求z=~x;即x 位反的值
System.out.println("4_5:"+z);
z = x << y; //求z=x<<y;即x 左移y 位的值
System.out.println("4_6:"+z);
z = x >>> y; //求z=x>>>y;即x 无符号右移y 位的值
System.out.println("4_7:"+z);
【5】假设x=10，y=20，z=30，求下列布尔表达式的值：
(1) x<10 || x<10
(2) x>y && y>x
(3) (x<y+z) && (x+10<=20)
(4) z-y==x && (y-z)==x
(5) x<10 && y>x
(6) x>y || y>x
(7) !(x<y+z) || !(x+10<=20)
(8) ( !(x==y)) && (x !=y) && (x<y || y<x)
[解答]：
public class Test_5 {
public static void main(String[] args) {
int x = 10, y = 20, z = 30;
boolean flag;
//求x<10||x<10 布尔值
flag = x < 10 || x < 10;
System.out.println("5_1:"+flag);
//求x>y&&y<x 布尔值
flag = x > y && y < x;
System.out.println("5_2:"+flag);
//求(x<y+z)&&(x+10<=20)布尔值
flag = (x < y + z) && (x + 10 <= 20);
System.out.println("5_3:"+flag);
//求z-y==x&&(y-z)==x 布尔值
flag = z - y == x && (y - z) == x;
System.out.println("5_4:"+flag);
//求x<10&&x>10 布尔值
flag = x < 10 && x > 10;
System.out.println("5_5:"+flag);
//求x>y||y>x 布尔值
flag = x > y || y > x;
System.out.println("5_6:"+flag);
//求!(x<y+z)||!(x+10<=20)布尔值
flag = !(x < y + z) || !(x + 10 <= 20);
System.out.println("5_7:"+flag);
//求(!(x==y))&&(x!=y)&&(x<y||y<x)布尔值
flag = (!(x == y)) && (x != y) && (x < y || y < x);
System.out.println("5_8:"+flag);
【6】什么是表达式？ 什么是语句？
[解答]：表达式是由运算符，操作数与方法调用按照语言的语法构造而成的符号序列。表达式可用于计算一个格式，位变量赋值以与帮助控制程序执行流程。
语句：语句组成了一个执行程序的基本单元，类似于自然语言的句子。包括表达式语句、复合语句、控制语句等。
【7】Java 有哪些数据类型？请描述其分类情况。
[解答]：Java 定义了8 个基本数据类型：字节型，短整型，整型，长整型，字符型，浮点型，双精度型，布尔型。它们分为4 组：
1) 整数型（byte，short，int，long）
2) 浮点数型（float，double）
3) 字符型（char）
4) 布尔型（boolean）
【8】试比较break 与continue 语句的区别？
[解答]：Break：强行退出循环，忽略循环体中的任何其他语句与循环的条件的条件测试。Continue：语句用来终止本次循环。其功能是终止当前正在进行的本轮循环，即跳过后面剩余的语句，转而执行循环的第一条语句，计算与判断循环条件，决定是否进入下一轮循环。
【9】有一函数：
x (x<1)
y = 3x-2 (1≤x<10)
4x (x≥10)
编写一程序，给定 x 值，输出y 值。
[解答]：
import java.io.*;
public class Test_9 {
public static void main(String[] args) throws NumberFormatException,IOException {
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
System.out.println("请输入数字x 的值:");
double x = Double.parseDouble(br.readLine());
double y = 0;
if (x < 1) {
y = x;
} else {
if (x >= 1 && x < 10) {
y = 3 * x - 2;
} else {
y = 4 * x;
System.out.println("y=" + y);
【10】说明while 与do......while 语句的差异。
[解答]：Do-while 与while 语句的主要区别在于，先执行循环体中的语句再计算条件表达式，所以do-while 语句的循环体至少执行一次。
【11】写出下列语句执行后的结果：
for (k=1;k<=5;k++)
if (k>4) break;
System.out.println(“k=”+k);
[解答]：
public class Test_11 {
public static void main(String[] args) {
int k;
for (k = 1; k <= 5; k++) {
if (k > 4)
break;
System.out.println("k=" + k);
【12】编写程序，求的值。
[解答]：
public class Test_12 {
public static void main(String[] args) {
int k,sum=0;
for(k=1;k<=10;k++){
sum=sum+k*k;
System.out.println("sum="+sum);
【13】编写一程序，输入3 个数，能按大小顺序输出。
[解答]：
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Test_13 {
public static void main(String[] args) throws NumberFormatException,IOException
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
int a[] = new int[3];
int k, temp;
System.out.println("请输入3 个数字(每输入一个数字后请换行)");
for (int i = 0; i < 3; i++) {
a[i] = Integer.parseInt(br.readLine());
for (int i = 0; i < a.length; i++) {
k = i;
for (int j = k + 1; j < a.length; j++) {
if (a[j] < a[k]) {
k = j;
if (k != i) {
temp = a[i];
a[i] = a[k];
a[k] = temp;
System.out.println("从小到大排序：");
for (int i = 0; i < a.length; i++) {
System.out.print(a[i] + " ");
【14】编写一各Java 程序，查找1～100 之间的素数并将运行结果输出。
[解答]：
public class Test_14 {
public static void main(String[] args) {
int m, k, i, n = 0;
for (m = 2; m <= 100; m=m++) {
for (i = 2; i <=m; i++)
if (m % i == 0) {
break;
if (m=i) {
System.out.print(m + " ");
n = n + 1;
if (n % 10 == 0)
System.out.println();
【15】运行下面程序，并分析其执行过程：
Public class multiplication{
public static void main(String args[ ]){
int i,j;
for (i=1;i<10;i++){
for (j=1;j<10;j++){
System.out.print(i+”*”+j+”=”+i*j+””);
System.out.println();
[解答]：
public class Test_15 {
public static void main(String[] args) {
int i, j;
for (i = 1; i < 10; i++) {
for (j = 1; j <= i; j++) {
System.out.print(i + "*" + j + "=" + i * j + " ");
System.out.println();
结果：
1*1=1
2*1=2 2*2=4
3*1=3 3*2=6 3*3=9
4*1=4 4*2=8 4*3=12 4*4=16
5*1=5 5*2=10 5*3=15 5*4=20 5*5=25
6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36
7*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49
8*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64
9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81
乘法表
【16】编写程序实现：输入一组整数，比较并输出其中的最大值与最小值，再将数组元素从小到大排序并将运行结果输出。
[解答]：
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Test_16 {
public static void main(String[] args) throws NumberFormatException,IOException {
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
int a[] = new int[5];
int k, temp;
System.out.println("请输入5 个数字(每输入一个数字后请换行)");
for (int i = 0; i < 5; i++) {
a[i] = Integer.parseInt(br.readLine());
for (int i = 0; i < a.length; i++) {
k = i;
for (int j = k + 1; j < a.length; j++) {
if (a[j] < a[k]) {
k = j;
if (k != i) {
temp = a[i];
a[i] = a[k];
a[k] = temp;
System.out.println("最小数字："+a[0]);
System.out.println("最大数字："+a[a.length-1]);
System.out.println("从小到大排序：");
for (int i = 0; i < a.length; i++) {
System.out.print(a[i] + " ");
【17】编写打印下列图形的程序：
(1) (2) (3)
[解答]：
public class Test_17_1 {
public static void main(String[] args) {
int i, j;
for (i = 1; i <= 4; i++) {
for (j = 1; j <= i; j++) {
System.out.print("#" + " ");
System.out.println();
public class Test_17_2 {
public static void main(String[] args) {
int i, j, k;
for (i = 0; i < 4; i++) {
for (k = 0; k < i; k++) {
System.out.print(" ");
for (j = 0; j <= 6 - 2 * i; j++)
System.out.print("*");
System.out.println();
public class Test_17_3 {
public static void main(String[] args) {
int i=0,blank,j,star,input=5;//input 是输入的行数
String s="";
for( i = 0;i < input; i++ )
blank = Math.abs( i - input/2);
for( j = 1 ; j <= blank; j++ )
s += " ";
star = input - 2 * blank;
for( j = 1; j <= star ; j++ )
s += "$";
s += "\n" ;
System.out.print( s );
【18】考虑一个2×3 的数组a。
(1) 为a 写一个设声明。试问，这样的声明使a 有多少行，多少列，多少元素？
(2) 写出a 的第1 行的所有元素的名字。
(3) 写一条语句，置行1 列2 的元素为零。
(4) 写一个嵌套for 结构，将a 的每个元素初始化为零。
(5) 定一条语句，求第3 列元素的与。
[解答]：
(1) 数组a 有2 行，3 列，元素个数为6
(2) 第一行元素的名字为a[0][0],a[0][1],a[0][2]
(3) 置行1 列2 的元素为0,语句是a[0][1]=0;
(4)
for(int i=0;i<2;i++){
for(in j=0;j<3;j++){
a[i][j]=0;
(5)
int sum=0;
sum=a[0][2]+a[1][2];
【19】求3×3 矩形对角元素之与。
[解答]：
public class Test_19 {
public static void main(String[] args) {
int i, j, sum = 0;
int a[][] = new int[3][3];
for (i = 0; i < 3; i++) {
for (j = 0; j < 3; j++) {
a[i][j] = i + j;
//输出二维数组
for (i = 0; i < 3; i++) {
for (j = 0; j < 3; j++) {
System.out.print(a[i][j] + " ");
System.out.println();
//显示对角线之与
for (i = 0; i < 3; i++) {
sum = sum + a[i][i];
System.out.println("对角线之与：" + sum);
【20】编写一程序，查找某一字符串是否包含有“abc”。
[解答]：
public class Test_20 {
public static void main(String[] args) {
String s = "yangen abc";
int a = s.indexOf("abc");
//a 位找到abc 的下标，找不到则返回-1
if (a != -1) {
System.out.print("包含字符串abc");
} else {
System.out.print("不包含字符串abc");
【21】设一字符串中包含有大写字母的字符，也有小写字母的字符，编写一程序，将其中的大小写字母的字符分别输出。
[解答]：
public class Test_21 {
public static void main(String[] args) {
String s="sdfKJjKjjsjdfKKJkjkjSDFsdf";
String s1="",s2="",s3;
for(int i=0;i<s.length();i++){
s3="ABCDEFGHIJKLMNOPQRSTUVWXYZ";
if(s3.indexOf(s.charAt(i))!=-1){
s1=s1+s.charAt(i);
}else{
s2=s2+s.charAt(i);
System.out.println("大写字母：");
System.out.println(s1);
System.out.println("小写字母：");
System.out.println(s2);
【22】输出一字符串，统计其中有多少个单词。(单词之间用空格分隔)。
[解答]：
import java.util.*;
public class Test_22 {
public static void main(String[] args) {
int i = 0;
String s = "Hello world i love java";
StringTokenizer st = new StringTokenizer(s, " ");
while (st.hasMoreTokens()) {
i++;
System.out.println(st.nextToken());
System.out.print("单词个数 :" + i);
第3 章 面向对象程序设计基础
【1】什么是Java 程序使用的类？什么是类库？
[解答]：Java 程序的基本单位是类。对象是对事物的抽象,而类是对对象的抽象与归纳，找出事物的共性,把具有共同性质的事物归结为一类,得出一个抽象的概念——类。类是具有相同属性与方法的一组对象的集合，类是在对象之上的抽象，对象则是类的具体化，一旦建立类之后，就可用它来建立许多你需要的对象。
Java 的类库是系统提供的已实现的标准类的集合，是Java 编程的API(Application Program Interface)，它可以帮助开发者方便、快捷地开发Java 程序。
【2】如何定义方法？在面向对象程序设计中方法有什么作用？
[解答]：方法的定义由两部分组成：方法声明与方法体。方法声明的基本格式如下：
返回类型 方法名（形式参数）
… //方法体内容
方法声明包括方法名、返回类型与形式参数，方法的小括号是方法的标志；方法体为实现方法行为的Java 语句。
在面向对象程序设计中，方法所起的作用是完成对类与对象属性操作。
【3】简述构造方法的功能与特点。下面的程序片段是某学生为student 类编写的构造方法，请指出其中的错误。
void Student(int no,String name)
studentNo=no;
studentName=name;
return no;
[解答]：构造方法是一个特殊的方法，主要用于初始化新创建的对象。构造方法的方法名要求与类名相同，用户不能直接调用，只能通过new 运算符调用，而且构造方法是不返回任何数据类型，甚至也不返回void 数据类型，即不能在构造方法前加void。
以上的代码段出错于：①构造方法Student()前不能加void ②不能用return 语句
【4】定义一个表示学生的student 类，包括的域有学号、姓名、性别、年龄，包括的方法有获得学号、姓名、性别、年龄与修改年龄。编写Java 程序创建student 类的对象与测试其方法的功能。
[解答]：程序代码段如下：
class student{
private String id;
private String name;
private String sex;
private int age;
public String getId()
{return id; }
public String getName()
{ return name; }
public String getSex()
{ return sex; }
public int getAge()
{ return age; }
void setAge(int age)
{ this.age = age; }
public class TestStudent
{ public static void main(String args[])
{ student stu = new student("0401398", "杨小明", "男",20);
System.out.println("student info: " + "\n 学号："+stu.getId()+ "\n 姓名"+
stu.getName()+"\n 性别："+stu.getSex()+ "\n 年龄："+stu.getAge());
stu.setAge(19);
System.out.println("修改后的年龄为："+stu.getAge());
【5】扩充、修改程序。为第4 题的student 类定义构造函数初始化所有的域，增加一个方法public String printInfo()把student 类对象的所有域信息组合形成一个字符串，并在主类中创建学生对象与测试各方法的功能。
[解答]：程序代码段如下：
class student{
private String id;
private String name;
private String sex;
private int age;
student(String id , String name, String sex, int age)
{ this.id = id;
this.name = name;
this.sex = sex;
this.age=age;
public String getId()
{return id; }
public String getName()
{ return name; }
public String getSex()
{ return sex; }
public int getAge()
{ return age; }
void setAge(int age)
{ this.age = age; }
public String printInfo()
{ String s= "student info: " + "\n 学号："+id+ "\n 姓名"+name+"\n 性别："+sex+ "\n 年龄"+age;
System.out.println(s);
return s;
public class TestStudent
{ public static void main(String args[])
{ student stu = new student("0401398", "杨小明", "男",20);
stu.printInfo();
stu.setAge(19);
stu.printInfo();
【6】什么是修饰符？修饰符的种类有哪些？它们各有什么作用？
[解答]：修饰符是用于限定类对象使用的权限，从而实现类中成员的信息隐藏。访问修饰符适用于类成员，而不是方法内部的局部变量。Java 常见的访问修饰符有这4 种：private、default、protected 与public。
(1) public 可以被所有的类访问
(2) pravite 只能被类本身访问，其他类无法访问
(3) protected 可以被类本身、它的子类（包括同一个包中以与不同包中的子类）
(4) default 属于默认的访问状态，可以被类本身与同一个包中的类访问
【7】什么是抽象类？为什么要引入抽象类的概念？
[解答]：抽象类是用来描述人们在对问题领域进行分析、设计中得出的抽象概念，是对一系列看上去不同，但是本质上相同的具体概念的抽象。抽象类不具备实际功能，是专门设计用来让子类继承的类，把这些具有共同特征的方法抽象出来，由子类负责这些抽象方法的实现细节，而父类仅提供此方法的名称与声明、没有方法的主体,该类。
【8】什么是抽象方法？如何定义、使用抽象方法？
[解答]：用abstract 关键字修饰的方法称为抽象方法。抽象方法定义时，需在方法名前加上关键字abstract，抽象方法只有方法声明，没有代码实现的空方法。因此，必须通过其子类来重写父类中定义的每一个抽象方法。
【9】包的作用是什么？如何在程序中引入已定义的类？使用已定义的用户类、系统类有哪些主要方式？
[解答]：包的作用是将类与接口封装在一起，方便了类与接口的管理与调用。要引入包中已定义的类，必须用关键字import 来导入这些类所在的包。import 语句的一般形式如下：
import 包名.类名
其中类名可以用通配符 “*”代替。
使用已定义的用户类、系统类主要有三种方式：直接调用、继承与创建已定义的用户类、系统类的对象。但无论采用哪种方式，使用已定义的用户类、系统类的前提条件是用户类、系统类应该是用户程序可见的类，为此用户程序需要用import 语句引人它所用到的用户类、系统类或用户类、系统类所在的包。
【10】什么是继承？如何定义继承关系？
[解答]：同类事物具有共同性，在同类事物中，每个事物又具有其特殊性。运用抽象的原则舍弃对象的特殊性，抽取其共同性，则得到一个适应于一批对象的类，这便是基类（父类）,而把具有特殊性的类称为派生类（子类），派生类的对象拥有其基类的全部或部分属性与方法，称作派生类对基类的继承。
派生类继承基类，必须使用关键字extends 来声明。比如派生类B 继承基类A，派生类B 定义的一般形式如下：
class B extends A
【11】什么是多态，如何实现多态？
[解答]：多态是指一个程序中同名的不同方法共存的情况。这些方法同名的原因是它们的最终功能与目的都相同，但是由于在完成同一功能时，可能遇到不同的具体情况，所以需要定义含不同的具体内容的方法，来代表多种具体实现形式。多态通常是一个消息在不同的类中用不同的方法实现的。
多态的实现是由消息的接收者确定一个消息应如何解释，而不是由消息的发送者确定，消息的发送者只需要指导另外的实例可以执行一种特定操作即可。Java 中提供两种多态机制：方法重载与方法重写。
【12】解释this 与super 的意义与作用。
[解答]： this 指的是引用当前对象或类名称，当一个类的实例变量名与一个方法中参数名相同时，则参数就隐藏了实例变量名，此时可通过使用关键字this 来访问它；super 用来引用当前对象的父类，通过super 来访问父类被子类隐藏的成员变量、成员方法以与父类的构造方法。由于子类不继承父类的构造方法，可使用super 来调用父类的构造方法，并且super必须是子类构造方法中的第一条语句。
【13】什么是接口？为什么要定义接口？接口与类有什么异同？
[解答]：接口是用来调节各类之间的相互关系的一种结构，接口是抽象类的一种，只包含常量与方法的定义，而没有变量与具体方法的实现，且其方法都是抽象方法。
接口定义的格式如下：
[public] interface 接口名 [extends 父接口名列表]{
… //接口体
extends子句有类声明的extends子句基本相同，不同的是一个接口可有多个父接口，用逗号隔开，而一个类只能有一个父类。Java中的类只能实现单重继承，这虽然可以简化编程，但毕竟没有完全实现面向对象的功能。定义接口的主要作用，就是帮助Java实现类间多重继承的结构。而且接口还有以下好处：