Java核心技术习题答案

Java核心技术
习题答案
马志强张然李雷孝编
清华大学出版社
目录
第一章Java语言概述 (3)
第二章 Java语法基础 (4)
第三章面向对象编程 (15)
第四章数组 (38)
第五章高级类特性 (45)
第六章 GUI编程 (51)
第七章集合框架 (62)
第九章集合框架 (77)
第十章 IO流 (81)
第十一章 JDBC访问数据库 (84)
第十二章线程 (85)
第十三章网络编程 (90)
第一章Java语言概述
一、选择题
1-5 ABBBB
6-8 AAB
二、填空题
1. MyClass MyClass.class
2. String数组（String[]）一
3. javac A.java java A
三、程序设计题
1、搭建Java运行环境，并写一个Java程序打印输出“开始学习Java程序设计！”。

1）首先安装JDK；
2）配置环境变量path，classpath可配可不配；
3）FirstJava.java
public class HelloWorld{
public static void main(String[] args){
开始学习Java程序设计！");
}
}
2、修改下面四个Java源文件中的错误，使其能够编译和运行。

Test1.java：TestAnother1类不能再使用public修饰，一个源文件中只能有一个类或者接口用public修饰；
Test2.java：源文件中public修饰的类的名字为Testing2，和源文件名字不一致；
Test3.java：Test3类的main方法的形参类型为String[]；
Test4.java：Test4类的main方法必须使用static关键字修饰。

第二章 Java语法基础
一、选择题
1-5 BCADB
6-9 DCCC
二、填空题
1. abc ，a1， _abc， _1a， ab123
#a，const，$abc，1abc，if，$#1sa，$_a，_$q1
2.题目出现问题：代码修改为 ch = (char) (ch+1);结果为’B’;如果直接结果为98。

3.true(真) false(假)
4.4
5. 2 2 false 2
6.m*20/100 (double)m*20/100
三、编程题
1、由命令行输入一个成绩，使用switch结构求出成绩的等级。

A：90－100；B：80－89；C：70－79；D：60－69；E：0－59。

public class IfElseTest {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int grade = sc.nextInt();
if(grade<0 || grade>100){
System.exit(0);
}
int temp =(int)Math.floor(grade/10);
switch(temp){
case 10:{
break;
}
case 9:{
break;
}
case 8:{
break;
}
case 7:{
break;
}
case 6:{
break;
}
default:{
break;
}
}
}
}
2、计算圆周率：PI＝4－4/3+4/5-4/7... ...；打印出第一个大于3.1415小于3.1416的值。

public class PITest{
public static void main(String[] args){
double result=0.0;
for(int i=1;;i++){
double m=4.0/(2*i-1);
if((i%2)==0){
result-=m;
}else{
result+=m;
}
if(result>3.1415 && result<3.1416){
break;
}
}
}
}
3、输入一个数据n，计算斐波那契数列(Fibonacci)的第n个值。

斐波那契数列：1、1、2、3、5、8、13、21、3
4、……。

public class FibonacciTest{
public static void main(String[] args){
Scanner sn=new Scanner(System.in);
int num=sn.nextInt();
int i=1;
int n1=1,n2=1;
while(i<=num){
if(i==1||i==2){
n2=1;
}else{
int temp=n2;
n2=n1+n2;
n1=temp;
}
i++;
}
第"+num+"个值为："+n2);
}
}
4、计算多项式1-1/3+1/5-1/7+1/9......的值。

1）要求出前50项和值。

2）要求出最后一项绝对值小于1e-5的和值。

public class SumTest{
public static void main(String[] args){
double sum=0.0;
for(int i=1;i<=50;i++){
if(i%2==0){
sum=sum-1.0/(2*i-1);
}else{
sum=sum+1.0/(2*i-1);
}
}
前50项和值:"+sum);
double item=0.0;
int j=1;
sum=0.0;
while(item<0.00001){
item=1.0/(2*j-1);
if(j%2==0){
sum-=item;
}else{
sum+=item;
}
j++;
}
最后一项绝对值小于1e-5的和值:"+sum);
}
}
5、产生100个0-999之间的随机整数，然后判断这100个随机整数哪些是素数，哪些不是？
public class PrimeTest {
public static void main(String[] args) {
PrimeTest t = new PrimeTest();
for(int i=0;i<100;i++){
int num = (int)(Math.random()*1000);
if(t.isPrime(num)){
是素数！");
}else{
不是素数！");
}
}
}
public boolean isPrime(int num){
for(int i=2;i<=num/2;i++){
if(num%i==0){
第一个被"+i+"整除！");
return false;
}
}
return true;
}
}
6、在屏幕上打印出n行的金字塔图案，如，若n=3，则图案如下：
*
***
*****
public class PrintStar{
public static void main(String[] args){
Scanner sn=new Scanner(System.in);
int rows=sn.nextInt();
for(int i=1;i<=rows;i++){
for(int j=1;j<=rows-i;j++){
}
for(int k=1;k<=2*i-1;k++){
}
}
}
}
7、歌德巴赫猜想，任何一个大于六的偶数可以拆分成两个质数的和，打印出所有的可能。

如输入10，结果为：10=5+5；10=3+7。

public class Gede {
public static void main(String[] args) {
int n = Integer.parseInt(args[0]);
if(n<=6 || n%2!=0){
错误的参数！");
return;
}
Gede g = new Gede();
//因为1不是素数，n-2是偶数，所以从3开始循环
for(int i=3;i<=n/2;i++){
if(i%2==0){
continue;
}
if(g.isPrime(i) && g.isPrime(n-i)){
}
}
}
/**
* 判断num是否是素数
*/
public boolean isPrime(int num){
for(int i=2;i<=num/2;i++){
if(num%i==0){
return false;
}
}
return true;
}
}
四、实训题
万年历的设计与实现。

本程序包含两个类CalenderModelA和TestCalenderModelA。

CalenderModelA实现了赛事日期设置等主要功能，程序文件CalenderModelA .java。

public class CalenderModelA
{
//计算从公元始的天数
public int getNumberOfDay(int year, int month, int day)
{
int total = 0;
int limit = getTotalDaysOfMonth(year, month);
if(day<=limit)
{
for (int y = 1; y < year; y++)
{
total += (this.isLeapYear(year) ? 366 : 365);
}
for (int m = 1; m < month; m++)
{
total += (this.getTotalDaysOfMonth(year, month));
}
total+=day;
return total;
}
else
{
您输入的日期非法");
return -1;
}
}
//打印万年历
public void show(int year, int month)
{
int total = 0;
//计算从公元始到今年之前的总天数
for (int y = 1; y < year; y++)
{
total += (this.isLeapYear(y) ? 366 : 365);
}
//计算今年到本月前的总天数
for (int m = 1; m < month; m++)
{
total += (this.getTotalDaysOfMonth(year, m));
}
//计算本月1日是星期几
total = total % 7;
int d1 = (total + 1) % 7;
int d2 = this.getTotalDaysOfMonth(year, month);
年" + month + "月");
String[] s = { "日", "一", "二", "三", "四", "五", "六" };
for (int i = 0; i < 7; i++) {
}
for(int i=0;i<d1;i++){
}
//打印本月日历
for (int i = d1,j=1; i < d1 + d2; i++,j++) {
if((i+1)%7 == 0){
}
}
}
//判断是否为闰年
public boolean isLeapYear(int year)
{
return ((year%4 == 0) && (year % 100 != 0)) || (year % 400 == 0); }
//计算某年某月天数
public int getTotalDaysOfMonth(int year, int month)
{
int total = 0;
switch (month) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
total = 31;
break;
case 2:
total = this.isLeapYear(year) ? 29 : 28;
break;
case 4:
case 6:
case 9:
case 11:
total = 30;
break;
}
return total;
}
}
TestCalenderModelA实现main方法，具有输入大赛起始和终止日期，输出日历，并计算大赛周期的功能。

程序文件TestCalenderModelA .java。

public class TestCalenderModelA
{
public static void main(String[] args)
{
Scanner scan = new Scanner(System.in);
请输入年份:");
int year = scan.nextInt();
请输入月份:");
int month = scan.nextInt();
月历如下");
CalenderModelA testBegin = new CalenderModelA();
testBegin.show(year, month);
}
}
第三章面向对象编程
一、选择题
1-5 CABDD
2-10 DCCBC
11-12 CC
二、填空题
1.Package mypackage ;
2.final
3.Object
4.package import class
5.c
三、程序设计题
2、按下列要求编写程序：
①创建Teacher类
要求：Teacher类要描述姓名、年龄、薪水，类型分别为String、int、double
②创建TeacherTest类
要求：在TeacherTest类中创建Teacher的对象；为该对象的属性（姓名、性别、年龄）赋值；将该对象的属性（姓名、性别、年龄）输出；
③为Teacher类添加一个方法，用于在教师原有薪水的基础上增加5000；
④修改TeacherTest类，增加对教师增加薪水方法的调用，并将增加后的薪水值输出。

Teacher.java：
public class Teacher {
public String name;
public int age;
public double salary;
public String getName() {
return name;
}
public void setName(String name) {
= name;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
public Teacher(){
}
public Teacher(String name,int age,double salary){
=name;
this.age=age;
this.salary=salary;
}
public void addSalary(){
this.salary=this.salary+5000;
}
}
TeacherTest.java：
public class TeacherTest {
public static void main(String[] args) {
Teacher teacher=new Teacher();
teacher.age=35;
="zhangsan";
teacher.salary=1234.5;
teacher.addSalary();
}
}
①包含以下属性：String name; int age; boolean gender; Person partner。

②定义marry(Person p)方法，代表当前对象和p结婚，如若可以结婚，则输出恭贺信息，否则输出不能结婚原因。

下列情况不能结婚：结婚年龄，男<24，女<22；3，某一方已婚。

③定义测试类，来测试以上程序。

public class Person{
private String name;
private int age;
private boolean gender;
Person partner;
public Person(String name,int age,boolean gender,Person partner){
=name;
this.age=age;
this.gender=gender;
this.partner=partner;
}
public void marry(Person p){
if(this.gender==p.gender){
同性不能结婚！");
return;
}
if((this.gender==true && this.age<24)||(this.gender==false && this.age<22)
|| (p.gender==true && p.age<24) || (p.gender==false && p.age<22)){
没有达到结婚年龄！");
return;
}
if(this.partner!=null || p.partner!=null){
有一方已经结婚！");
return;
}
祝你们新婚愉快！");
this.partner=p;
p.partner=this;
}
Person p1=new Person("关之琳",23,false,null);
Person p2=new Person("刘德华",26,true,null);
Person p3=new Person("孙楠",70,true,null);
p1.marry(p2);
p1.marry(p3);
}
}
4、定义一个Animal类，该类有两个私有属性，name(代表动物的名字)和legs(代表动物的腿的条数)。

①两个构造方法，一个无参，默认给name赋值为AAA,给legs赋值为4；另一个需要两个参数，分别用这两个参数给私有属性赋值。

②两个重载的move()方法，其中一个无参，在屏幕上输出一行文字: XXX Moving!!(XXX为该动物的名字)；另一个需要一个int参数n,在屏幕上输出n次 XXX Moving!!
public class Animal1 {
private String name;
private int legs;
public Animal1(){
="AAA";
this.legs=4;
}
public Animal1(String name,int legs){
super();
=name;
this.legs=legs;
}
public String getName() {
return name;
}
public void setName(String name) {
= name;
}
public int getLegs() {
return legs;
public void setLegs(int legs) {
this.legs = legs;
}
public void move(){
}
public void move(int n){
int i=1;
while(i<=n){
i++;
}
}
}
5、定义一个Fish类，继承自Animal类。

①提供一个构造方法，该构造方法需要一个参数name，并给legs赋默认值0；
②覆盖Animal类中的无参move()方法，要求输出：XXX Swimming!!
public class Fish extends Animal {
private String name;
private int legs;
public Fish(String name){
=name;
this.legs=0;
}
public void move(){
}
}
public class Bird extends Animal {
private String name;
private int legs;
public Bird(String name){
=name;
this.legs=2;
}
public void move(){
}
6、写一个类Zoo，要求分别生成若干个Animal、Fish和Bird。

并调用他们的属性和方法。

public class Zoo {
public static void main(String[] args) {
Animal a=new Animal("dog",4);
a.move();
a.move(3);
Fish f=new Fish("small fish");
f.move();
Bird b=new Bird("xique");
b.move();
Animal af=new Fish("small fish");
af.move();
}
}
7、某公司的雇员分为以下若干类：
①Employee：这是所有员工总的父类，属性：员工的姓名,员工的生日月份。

方法：getSalary(int month) 根据参数月份来确定工资，如果该月员工过生日，则公司会额外奖励100元。

②SalariedEmployee：Employee的子类，拿固定工资的员工。

属性：月薪；
③HourlyEmployee：Employee的子类，按小时拿工资的员工，每月工作超出160小时的部分按照1.5倍工资发放。

属性：每小时的工资、每月工作的小时数；
④SalesEmployee：Employee的子类，销售人员，工资由月销售额和提成率决定。

属性：月销售额、提成率。

⑤BasedPlusSalesEmployee：SalesEmployee的子类，有固定底薪的销售人员，工资由底薪加上销售提成部分。

属性：底薪。

写一个程序，把若干各种类型的员工放在一个Employee数组里，写一个函数，打印出某月每个员工的工资数额。

注意：要求把每个类都做成完全封装，不允许非私有化属性。

class Employee{
private String name;
private int month;
public Employee(String name,int month){
=name;
this.month=month;
public String getName(){
return name;
}
public double getSalary(int month){
if(this.month==month){
return 100.0;
}
return 0.0;
}
}
class SalariedEmployee extends Employee{
private double monthSalary;
public SalariedEmployee(String name,int month,double monthSalary){ super(name,month);
this.monthSalary=monthSalary;
}
public double getSalary(int month){
return monthSalary+super.getSalary(month);
}
}
class HourlyEmployee extends Employee{
private int hours;
private double hourSalary;
public HourlyEmployee(String name,int month,int hours,double hourSalary){ super(name,month);
this.hours=hours;
this.hourSalary=hourSalary;
}
public double getSalary(int month){
double result;
if(hours<=160){
result=hours*hourSalary;
}else{
}
return result+super.getSalary(month);
}
}
class SalesEmployee extends Employee{
private double salesCount;
private double rate;
public SalesEmployee(String name,int month,double salesCount,double rate){
super(name,month);
this.salesCount=salesCount;
this.rate=rate;
}
public double getSalary(int month){
return salesCount*rate+super.getSalary(month);
}
}
class BasedPlusSalesEmployee extends SalesEmployee {
private double basedPlus;
public BasedPlusSalesEmployee(String name,int month,double salesCount,double rate,double basedPlus){
super(name,month,salesCount,rate);
this.basedPlus=basedPlus;
}
public double getSalary(int month){
return basedPlus+super.getSalary(month);
}
}
public class EmployeeTest{
public static void main(String[] args){
Employee[] e=new Employee[4];
e[0]=new SalariedEmployee("zhangsan",9,3222.90);
e[1]=new HourlyEmployee("lisi",5,230,23.90);
e[2]=new SalesEmployee("wangwu",11,2330000.0,0.005);
for(int i=0;i<e.length;i++){
月份的工资总额为："+e[i].getSalary(9));
}
}
}
四、实训题
班级成绩管理系统实体类设计。

public class Test {
public static void main(String[] args){
stu.setXueyuan("信息工程学院");
stu.setZhuanye("软件工程");
stu.setBanji("软件10-1");
Grade stugrade =new Grade();
stugrade.setKcm("Web程序设计");
stugrade.setXq("2011-2012(下)");
stugrade.setCj(90.5f);
stu.getGrades().addGrade(stugrade);
stugrade =new Grade();//加这一句的区别
stugrade.setKcm("计算机网络");
stugrade.setXq("2011-2012(上)");
stugrade.setCj(86.5f);
stu.getGrades().addGrade(stugrade);
stugrade =new Grade();//加这一句的区别
stugrade.setKcm("计算机组成原理");
stugrade.setXq("2011-2012(上)");
stugrade.setCj(66.5f);
stu.getGrades().addGrade(stugrade);
stugrade =new Grade();//加这一句的区别
stugrade.setKcm("数据结构");
stugrade.setXq("2010-2011(上)");
stugrade.setCj(76.5f);
stu.getGrades().addGrade(stugrade);
stugrade.setKcm("数据库原理");
stugrade.setXq("2010-2011(下)");
stugrade.setCj(76.5f);
stu.getGrades().addGrade(stugrade);
stugrade =new Grade();//加这一句的区别
stugrade.setKcm("高等数学（1）");
stugrade.setXq("2009-2010(上)");
stugrade.setCj(88.5f);
stu.getGrades().addGrade(stugrade);
stugrade =new Grade();//加这一句的区别
stugrade.setKcm("高等数学（2）");
stugrade.setXq("2009-2010(下)");
stugrade.setCj(68.5f);
stu.getGrades().addGrade(stugrade);
stugrade =new Grade();//加这一句的区别
stugrade.setKcm("软件工程专业外语");
stugrade.setXq("2011-2012(下)");
stugrade.setCj(88.0f);
stu.getGrades().addGrade(stugrade);
puteZc("2011-2012(下)");
stu.getGrades().sortByxq();
}
}
public class Student{
private String sid;
private String sname;
private String xueyuan;//先使用具体的字符串，然后转化成编码xyid private String zhuanye;
private String banji;
//
private GradeArray grades;
private ZcGrade zcGrade;
private void autoId(){
}
public Student() {
sid = new Long(id).toString();
autoId();
grades = new GradeArray();
}
public Student(String sid){
this(sid,null);
}
public Student(String sid,String sname){
this(sid,sname,null);
}
public Student(String sid,String sname,String xueyuan){ this.sid = sid;
this.sname = sname;
this.xueyuan =xueyuan;
grades = new GradeArray();
}
public String getSid() {
return sid;
}
public void setSid(String sid) {
this.sid = sid;
}
public String getSname() {
return sname;
}
public void setSname(String sname) {
this.sname = sname;
}
public String getXueyuan() {
return xueyuan;
}
this.xueyuan = xueyuan;
}
public String getZhuanye() {
return zhuanye;
}
public void setZhuanye(String zhuanye) {
this.zhuanye = zhuanye;
}
public String getBanji() {
return banji;
}
public void setBanji(String banji) {
this.banji = banji;
}
public GradeArray getGrades() {
return grades;
}
public void setGrades(GradeArray grades) {
this.grades = grades;
}
public ZcGrade getZcGrade() {
return zcGrade;
}
public void setZcGrade(ZcGrade zcGrade) {
this.zcGrade = zcGrade;
}
public void computeZc(String xqid){
zcGrade = new ZcGrade(xqid);
float sum = 0;
for(int i=0;i<grades.getCurrent();i++){
if(xqid.equals(grades.getGrade()[i].getXq())){
sum += grades.getGrade()[i].getCj();
}
zcGrade.setZcresult(sum);
}
@Override
public boolean equals(Object obj) {
// TODO Auto-generated method stub
boolean result = false;
if(obj!=null){
if(obj instanceof Student){
Student temp = (Student) obj;
if(sid.equals(temp.sid)){
result = true;
}
}
}
return result;
}
@Override
public String toString() {
// TODO Auto-generated method stub
String result = "{"+sid+"\r";
/*for(KsGrade temp:grades.getGrade()){
result +="[";
result += temp;
result +="],";
}*/
for(int i= 0;i<grades.getCurrent();i++){
result +="[";
result += grades.getGrade()[i];
result +="]";
result +="\r";
}
//result = result.substring(0, result.length()-1);//去掉最后一个逗号
result += zcGrade;
}
}
public class Grade {
private String kcm;
private String xq;
private float cj;
public Grade() {
super();
}
public Grade(String kcm){
this(kcm,null);
}
public Grade(String kcm,String xq){
this(kcm,xq,0.0f);
}
public Grade(String kcm,String xq,float cj){
this.kcm = kcm;
this.xq = xq;
this.cj =cj;
}
public float getCj() {
return cj;
}
public void setCj(float cj) {
this.cj = cj;
}
public String getKcm() {
return kcm;
}
public void setKcm(String kcm) {
this.kcm = kcm;
}
}
public void setXq(String xq) {
this.xq = xq;
}
@Override
public String toString() {
// TODO Auto-generated method stub
return kcm+":"+xq+":"+cj;
}
@Override
public boolean equals(Object obj) {
// TODO Auto-generated method stub
boolean result =false;
if(obj!=null){
if(obj instanceof Grade){
Grade temp = (Grade)obj;
if(kcm.equals(temp.kcm)){
result = true;
}
}
}
return result;
}
}
public class GradeArray {
public final static int KECHMENSHU = 50;
private Grade[] grades = new Grade[KECHMENSHU];
private int current =0;
public GradeArray() {
super();
}
public int getCurrent() {
}
public void setCurrent(int current) {
this.current = current;
}
public void addGrade(Grade g){
//存在问题：课程重复
if(current<KECHMENSHU){ if(!contain(g)){
grades[current++] = g;
}
}
}
public Grade[] getGrade() {
return grades;
}
public void setGrade(Grade[] grade) {
this.grades = grade;
}
private boolean contain(Grade g){
boolean result = false;
for(int i = 0;i<current;i++){
if(grades[i].equals(g)){
result = true;
break;
}
}
return result;
}
//增加成绩的删除、修改
//按照学期排序课程
public void sortByxq(){
//冒泡排序
for(int i = current-1;i>0;i--){
if(grades[j].getXq().compareToIgnoreCase(grades[j+1].getXq())>0){
Grade temp = grades[j+1];
grades[j+1] = grades[j];
grades[j] = temp;
}
}
}
}
}
public class GradeListStack {
/**
* @param args
*/
private Stack<Grade> gradelist;
GradeListStack(){
gradelist = new Stack<Grade>();
}
public void push(Grade grade){
gradelist.push(grade);
}
public Grade pop(){
return gradelist.pop();
}
public boolean isEmpty(){
return gradelist.empty();
}
public Stack<Grade> getGradelist() {
return gradelist;
}
public void setGradelist(Stack<Grade> gradelist) {
this.gradelist = gradelist;
}
@Override
// TODO Auto-generated method stub
String result = "{";
while(!gradelist.isEmpty()){
Grade grade = gradelist.pop();
result +="[";
result += grade.toString();
result +="],";
}
result = result.substring(0, result.length()-1);
result += "}";
return result;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
GradeListStack gradestack = new GradeListStack();
Grade grade = new Grade();
grade.setKcm("Web程序设计");
grade.setXq("6");
grade.setCj(88.0f);
gradestack.push(grade);
grade = new Grade();
grade.setKcm("SQL Server数据库应用");
grade.setXq("6");
grade.setCj(92.0f);
gradestack.push(grade);
}
}
public class ZcGrade {
private String xq;
private float zcresult;
public ZcGrade() {
super();
}
this.xq = xq;
}
public String getXqid() {
return xq;
}
public void setXqid(String xq) {
this.xq = xq;
}
public float getZcresult() {
return zcresult;
}
public void setZcresult(float zcresult) {
this.zcresult = zcresult;
}
@Override
public String toString() {
// TODO Auto-generated method stub
return xq+":"+zcresult;
}
}
第四章数组
一、选择题
1-5 ACCAA
二、填空题
1.sum=14
2. s=180
3.arr[i]<arr[j]
arr[j]=arr[i]
arr[i]=temp
三、程序设计题
（1）写一个类在其中定义一些方法实现数组元素的遍历、排序、插入、删除、查找。

public class ArrayTest{
public static void main(String[] args){
int[] a={11,2,-3,54,115,36};
int[] b={110,-9,78,27,6,225,94,32,-12,1111,0};
//调用处理数组的方法
print(a);
}
//遍历数组元素的方法
public void print(int[] a){
for(int i=0;i<a.length;i++){
}
}
//对数组元素进行排序的方法
public int[] sort(int[] a){
for(int i=0;i<a.length-1;i++){
for(int j=i+1;j<a.length;j++){
if(a[i]<a[j]){
int temp=a[i];
a[i]=a[j];
a[j]=temp;
}
}
}
return a;
}
//找出数组中值最大的元素
public int maxValue(int[] a){
int temp=a[0];
for(int i=1;i<a.length;i++){
if(temp<a[i])
temp=a[i];
}
return temp;
}
//求数组元素的和
public int sum(int[] a){
int sum=0;
for(int i=0;i<a.length;i++){
sum+=a[i];
}
return sum;
}
//将数组中的元素逆序排列
public int[] reverse(int[] a){
for(int i=0;i<a.length/2;i++){
int temp=a[i];
a[i]=a[a.length-i-1];
a[a.length-i-1]=temp;
}
return a;
}
}
（2）将一个数组中的元素倒排过来，不能新开一个数组的临时存储空间，只能在原数组上改。

public class ArrayReverse {
public int[] reverse(int[] a){
int len=a.length;
for(int i=0;i<len/2;i++){
int temp=a[i];
a[i]=a[len-i-1];
a[len-i-1]=temp;
}
return a;
}
public static void main(String[] args){
ArrayReverse ar=new ArrayReverse();
int[] a={1,2,3,4,5,6,7,8,9,10};
ar.reverse(a);
for(int i=0;i<a.length;i++){
}
}
}
（3）写一个类用来模拟栈这种数据结构，要求底层使用数组存储数据，并给出相应的进栈和出栈的方法。

public class MyStack{
int[] arr;//用于存放栈的数据
int count;//元素个数
public MyStack(int size){
arr=new int[size];
}
public void push(int num){
if(count==arr.length){
栈元素已满，"+num+"不能再添加！");
return;
}
arr[count++]=num;
}
public int pop(){
if(count==0){
栈为空，没有元素！");
return -1;
}
int num=arr[--count];
return num;
}
public void print(){
for(int i=count-1;i>=0;i--){
}
}
public static void main(String[] args){
MyStack ms=new MyStack(6);
ms.pop();
ms.push(10);
ms.push(50);
ms.push(80);
ms.push(20);
ms.push(340);
ms.push(120);
ms.push(69);
ms.print();
ms.pop();
ms.pop();
ms.print();
}
}
（4）实现在一个数组指定位置添加元素和删除元素的功能。

提示：解答该题需要考虑如下问题
①添加元素后超过数组容量时数组的扩展容量问题。

②添加元素前后数组中元素的变化。

③删除元素前后数组中元素的变化。

public class ArrayInsertDel{
int[] arr={20,18,12,39,23,100};
int count=6;
public void insert(int pos,int num){
if(arr.length==count){
expand();
}
for(int i=count;i>pos;i--){
arr[i]=arr[i-1];
}
arr[pos]=num;
count++;
}
public void delete(int pos){
count--;
for(int i=pos;i<=count;i++){
arr[i]=arr[i+1];
}
}
public void print(){
for(int i=0;i<count;i++){
}
}
public void expand(){
int[] arr2=new int[arr.length*2];
System.arraycopy(arr,0,arr2,0,arr.length);
arr=arr2;
}
public static void main(String[] args){
ArrayInsertDel aid=new ArrayInsertDel();
aid.print();
aid.insert(3,110);
aid.insert(5,119);
aid.print();
aid.delete(4);
aid.print();
} }
第五章高级类特性
一、选择题
1-5 ＡＤＡＣＣ
6-7 ＢＤ
二、填空题
一、一多
二、抽象 final
三、abstract extends new
四、不能
三、程序设计题
①建立一个动物的层次结构，以抽象类Animal为根，Cat、Spider和Fish动物类实现接口Pet。

使用接口和抽象类技术完成。

类结构如图5-6所示。

完成：
①创建Animal类，它是所有动物类的抽象父类
②创建Spider类，继承Animal类
③创建Pet接口
④创建Cat类，继承Animal类并实现Pet接口
⑤创建Fish类，继承Animal类并实现Pet接口
⑥使用AnimalsTest类测试代码。

图5-6 类结构
public class AnimalTest{
public static void main(String[] args){
Animal a;
a=new Spider();
a.walk();
a.eat();
a=new Cat();
a.walk();
a.eat();
Pet p;
p=new Fish();
p.setName("red fish");
p.play();
}
}
abstract class Animal{ protected int legs; protected Animal(int legs){
this.legs=legs;
}
public void walk(){
}
public abstract void eat();
}
interface Pet{
void setName(String name);
String getName();
void play();
}
class Spider extends Animal{
public Spider(){
super(6);
}
public void eat(){
}
}
class Cat extends Animal implements Pet{ private String name;
public Cat(String name){
super(4);
=name;
}
public Cat(){
super(4);
}
public void setName(String name){
=name;
}
public String getName(){
return name;
}
public void play(){
}
public void eat(){
}
}
class Fish extends Animal implements Pet{ private String name;
public Fish(){
super(0);
}
public void setName(String name){
=name;
}
public String getName(){
return name;
}
public void play(){
}
public void eat(){
}
public void walk(){
//super.walk(); }
}
第六章 GUI编程
一、填空题
A C C D
B B B
二、选择题
1.Graphical User Interface
2.事件监听器
3.BorderLayout 布局管理器
4.setFont
四、实训题
import
import
import
import
import
import
import
import
import
public class Calculator extends JFrame implements ActionListener { /** 计算器上的键的显示名字 */
private final String[] KEYS = { "7", "8", "9", "/", "sqrt", "4", "5", "6", "*", "%", "1", "2", "3", "-", "1/x", "0", "+/-", ".", "+", "=" };
/** 计算器上的功能键的显示名字 */
private final String[] COMMAND = { "Backspace", "CE", "C" };
/** 计算器左边的M的显示名字 */
private final String[] M = { " ", "MC", "MR", "MS", "M+" };
/** 计算器上键的按钮 */
private JButton keys[] = new JButton[KEYS.length];
/** 计算器上的功能键的按钮 */
private JButton commands[] = new JButton[COMMAND.length]; /** 计算器左边的M的按钮 */
private JButton m[] = new JButton[M.length];
/** 计算结果文本框 */
private JTextField resultText = new JTextField("0");
// 标志用户按的是否是整个表达式的第一个数字,或者是运算符后的第一个数字private boolean firstDigit = true;
// 计算的中间结果。

private double resultNum = 0.0;
// 当前运算的运算符
private String operator = "=";
// 操作是否合法
private boolean operateValidFlag = true;
/**
* 构造函数
*/
public Calculator() {
super();
// 初始化计算器
init();
// 设置计算器的背景颜色
this.setBackground(Color.LIGHT_GRAY);
this.setTitle("计算器");
// 在屏幕(500, 300)坐标处显示计算器
this.setLocation(500, 300);
// 不许修改计算器的大小
this.setResizable(false);
// 使计算器中各组件大小合适
this.pack();
}
/**
* 初始化计算器
*/
private void init() {
// 文本框中的内容采用右对齐方式
resultText.setHorizontalAlignment(JTextField.RIGHT);
// 不允许修改结果文本框
resultText.setEditable(false);
// 设置文本框背景颜色为白色
resultText.setBackground(Color.white);
// 初始化计算器上键的按钮，将键放在一个画板内
JPanel calckeysPanel = new JPanel();
// 用网格布局器，4行，5列的网格，网格之间的水平方向间隔为3个象素，垂直方向间隔为3个象素
calckeysPanel.setLayout(new GridLayout(4, 5, 3, 3));
for (int i = 0; i < KEYS.length; i++) {
keys[i] = new JButton(KEYS[i]);
calckeysPanel.add(keys[i]);
keys[i].setForeground(Color.blue);
}
// 运算符键用红色标示，其他键用蓝色表示
keys[3].setForeground(Color.red);
keys[8].setForeground(Color.red);
keys[13].setForeground(Color.red);
keys[18].setForeground(Color.red);
keys[19].setForeground(Color.red);
// 初始化功能键，都用红色标示。

将功能键放在一个画板内
JPanel commandsPanel = new JPanel();
// 用网格布局器，1行，3列的网格，网格之间的水平方向间隔为3个象素，垂直方向间隔为3个象素
commandsPanel.setLayout(new GridLayout(1, 3, 3, 3));
for (int i = 0; i < COMMAND.length; i++) {
commands[i] = new JButton(COMMAND[i]);
commandsPanel.add(commands[i]);
commands[i].setForeground(Color.red);
}
// 初始化M键，用红色标示，将M键放在一个画板内
JPanel calmsPanel = new JPanel();
// 用网格布局管理器，5行，1列的网格，网格之间的水平方向间隔为3个象素，垂直方向间隔为3个象素。