java程序设计基于JDK6和NetBeans实现宋波主编课后作业答案打印版.doc

java程序设计——基于JDK6和NetBeans实现课后答案
第一章课后作业答案
1. 试说明Java Application与Java Applet的不同之处。
答案：Java的用户程序分为两类：Java Application和Java Applet，这两类程序在组成结构和执行机制上都有一定的差异，主要体现在以下几方面：
（1）运行方式不同。Java Application是完整的程序，可以独立运行；Java Applet程序不能单独运行，它必须嵌入到用HTML语言编写的Web页面中，通过与Java兼容的浏览器来控制执行。
（2）运行工具不同。Java Application程序被编译以后，用普通的Java解释器就可以使其边解释边执行；而Java Applet必须通过网络浏览器或者Applet观察器才能执行。
（3）程序结构不同。每个Java Application程序必定含有一个并且只有一个main()方法，程序执行时，首先寻找main()方法，并以此为入口点开始运行；而Applet程序则没有含main()方法的主类，这也正是Applet程序不能独立运行的原因。尽管Applet没有含有main()方法的主类，但Applet一定有一个从java.applet.Applet派生的类，它是由Java系统提供的。
（4）受到的限制不同。Java Application程序可以设计成能进行各种操作的程序，包括读/写文件的操作，但是Java Applet对站点的磁盘文件既不能进行读操作，也不能进行写操作。然后，由于Applet的引入，使Web页面具有动态多媒体效果和可互交性能，这使由名为超文本、实为纯文本的HTML语言编写成的Web页面真正具有了超文本功能，不但可以显示文本信息，而且还可以有各种图片效果和动态图形效果，从而使页面显得生动美丽；另外，Applet使Web页面增加了按钮等功能，从而增加了交互性。
2. Java程序的最小程序单位是什么？
答案：Java语言以类作为程序的基本单位。
3. 下载并安装JDK 1.6以及Java API文档，编译并运行例1-1。
答案：实践题。
4. 编写一个Java应用程序，在屏幕上输出“欢迎进入Java奇妙世界！”的字符串。
答案：
public class HelloWorld {
public static void main(String[ ] args) {
System.out.println("欢迎进入Java奇妙世界！");
}}
5. 下面程序的功能是：计算并打印输出两个整数a和b之间的最大值，请填空。

01 public class Max{
02 public static void main (String args[ ] ) {
03 int max;
04 int a=3;
05 int b=5;
06 if(a>b){
07 max=a ;
08 }
09 else{
10 max=b ;
11 }
12 System.out.println(max);
13 }
14 }

【运行结果】 5
第2章 Java语言基础
1．请完成下面程序，使得程序的输出结果如右图所示。
*
* *
* * *
* * * *
* * * * *
* * * * *
* * * * * * *
* * * * * * * *
* * * * * * * * *
* * * * * * * * * *
01. public class LoopControl {
02. public static void main(String[] args) {
03. outer: for (int i = 0; i < 10; i++) {
04. for (int j = 0; j < 10; j++) {
05. if (j > i) {
06. System.out.println() ;
07. continue outer ;
08. }
09. System.out.print(" * ");
10. }
11. }
12. }
13. }

2．编写程序，输出英文字母A~Z及其对应的Unicode编码值。
01. public class CharUnicodeTest {
02. public static void main(String[] args) {
03. for(char c='A';c<='Z';c++){
04. System.out.print("Character: "+c);
05. System.out.println("\t"+"Unicode: "+(int)c);
06. }
07. }
08. }

3．编写程序，计算1!+2!+3!+…+20!的和。

01. public class NestedLoopTest {
02. public static void main(String[] args) {
03. long sum=0;
04. long fac;
05. for(int i=1;i<21;i++){
06. fac=1;
07. for(int j=1;j<=i;j++){
08. fac=fac*j;
09. }
10. sum=sum+fac;
11. }
12. System.out.println("1!+2!+...+20!="+sum);
13. }
14. }

4．编写程序，随机产生一个（50，100）之间的整数并判断其是否为素数。

01. public class RandomPrimeTest {
02. public static void main(String[] args) {
03. int i=(int)(Math.random()*49+51);
04. System.out.println("The random number is : "+i);
05. int j;
06. for(j=2;jime number");
13. }
14. }

5．编写程序，输出从1到9的乘法口诀表。
01. public class MultiTableTest {
02. public static void main(String[] args) {
03. for(int i=1;i<=9;i++){
04. for(int j=1;j<=i;j++){
05. System.out.print(i+"*"+j+"="+i*j+"\t");
06. }
07. System.out.println();
08. }
09. }
10. }

第4章 Java面向对象高级特性
1. 指出下面程序中出现编译错误的行数及其原因。
01. public class Outer {
02. private class Inner {
03. static String name=new String("Inner");
04. public void method(){
05. System.out.println(name);
06. }
07. }
08. public static void main(String[] args) {
09. Inner anew Outer().new Inner();
10. a.method();
11. }
12. }
上述代码中第3行会出现编译错误，内部类Inner中的成员变量不能定义为static。

2. 请完成下面程序，使得程序可以输出枚举常量值：RED、GREEN和BLUE。

01. public class Ball {
02. public enum T {
03. RED, GREEN, BLUE
04. }
05. public static void main(String[] args) {
06. Ball.T[] t=Ball.T.values();
07. for(int i=0;irgs) {
08. new Car().go();
09. }
10. void go() {
11. new Engine();
12. }
13. void drive() {
14. System.out.println("hi");
15. }
16. }

4. 应用抽象类及继承编写程序，输出本科生及研究生的成绩等级。要求：首先设计抽象类Student，它包含学生的一些基本信息：姓名、学生类型、三门课程的成绩和成绩等级等。其次设计Student类的两个子类：本科生类Undergraduate和研究生类Postgraduate，二者在计算成绩等级时有所区别，具体计算标准如表所示。最后创建测试类进行测试。
学生成绩等级
本科生标准
研究生标准
平均分85-100：优秀
平均分90-100：优秀
平均分75-85： 良好
平均分80-90： 良好
平均分65-75： 中等
平均分70-80： 中等
平均分60-65： 及格
平均分60-70： 及格
平均分60以下：不及格
平均分60以下：不及格
//抽象类Student

01. abstract class Student {
02. final static int COURSE_COUNT=3;
03. private String name;
04. private String type;
05. private int[] scores;
06. private String grade;
07. public Student(String name){
08. this.name=name;
09. }
10. public void setName(String name){
11. this.name=name;
12. }
13. public String getName(){
14. return name;
15. }
16. public void setType(String type){
17. this.type=type;
18. }
19. public String getType(){
20. return type;
21. }
22. public void setScores(int[] scores){
23. this.scores=scores;
24. }
25. public int[] getScores(){
26. return scores;
27. }
28. public void setGrade(String grade){
29. this.grade=grade;
30. }
31. public String getGrade(){
32. return grade;
33. }
34. public abstract String calculateGrade();
35. }

//本科生类

01. public class Undergraduate extends Student{
02. public Undergraduate(String name,int[] scores){
03. super(name);
04. this.setType("本科生");
05. this.setScores(scores);
06. }
07. public String calculateGrade(){
08. int average;
09. int sum=0;
10. int[] scores;
11. scores=this.getScores();
12. for(int i=0;iRSE_COUNT;
16. if(average>=85)
17. return "优秀";
18. else if(average>=75)
19. return "良好";
20. else if(average>=65)
21. return "中等";
22. else if(average>=60)
23. return "及格";
24. else
25. return "不及格";
26. }
27. }

//研究生类

01. public class Postgraduate extends Student{
02. public Postgraduate(String name,int[] scores){
03. super(name);
04. this.setType("研究生");
05. this.setScores(scores);
06. }
07. public String calculateGrade(){
08. int average;
09. int sum=0;
10. int[] scores;
11. scores=this.getScores();
12. for(int i=0;i=90)
17. return "优秀";
18. else if(average>=80)
19. return "良好";
20. else if(average>=70)
21. return "中等";
22. else if(average>=60)
23. return "及格";
24. else
25. return "不及格";
26. }
27. }

//测试类

01. public class StudentTest {
02. public static void main(String[] args){
03. Student[] s=new Student[10];
04. int[][] scores=new int[10][Student.COURSE_COUNT];
05. for(int i=0;i<5;i++){
06. for(int j=0;jT;j++){
07. scores[i][j]=(int)(Math.random()*61+40);
08. }
09. s[i]=new Undergraduate("本科生"+(i+1),scores[i]);
10. s[i].setGrade(s[i].calculateGrade());
11. }
12. for(int i=5;i<10;i++){
13. for(int j=0;j1+40);
15. }
16. s[i]=new Postgraduate("研究生"+(i-4),scores[i]);
17. s[i].setGrade(s[i].calculateGrade());
18. }
19. int[] c;
20. for(int i=0;i<10;i++){
21. System.out.print(s[i].getName()+"\t");
22. System.out.print(s[i].getType()+"\t");
23. c=s[i].getScores();
24. for(int j=0;j生5 本科生 54 78 53 及格
研究生1 研究生 83 61 86 中等
研究生2 研究生 91 57 85 中等
研究生3 研究生 70 96 55 中等
研究生4 研究生 43 75 62 及格
研究生5 研究生 43 80 61 及格

5. 应用枚举类编写程序，根据第4题的要求输出本科生及研究生的成绩等级。要求：将学生成绩等级定义成枚举类，其它功能不变，完成类的定义并进行测试。
//抽象类

01. abstract class Student {
02. //枚举类定义
03. static enum Grade {
04. DISTINCTION("优秀"),
05. MERIT("良好"),
06. AVERAGE("中等"),
07. PASS("及格"),
08. FAIL("不及格");
09. private String scoreGrade;
10. Grade(String scoreGrade) {
11. this.scoreGrade = scoreGrade;
12. }
13. public String getScoreGrade() {
14. return scoreGrade;
15. }
16. }
17. final static int COURSE_COUNT = 3;
18. private String name;
19. private String type;
20. private int[] scores;
21. private Grade sgrade;
22. public Student(String name) {
23. this.name = name;
24. }
25. public void setName(String name) {
26. this.name = name;
27. }
28. public String getName() {
29. return name;
30. }
31. public void setType(String type) {
32. this.type = type;
33. }
34. public String getType() {
35. return type;
36. }
37. public void setScores(int[] scores) {
38. this.scores = scores;
39. }
40. public int[] getScores() {
41 return scores;
42. }
43. public void setGrade(Grade sgrade) {
44. this.sgrade = sgrade;
45. }
46. public Grade getGrade() {
47. return sgrade;
48. }
49. public abstract Grade calculateGrade();
50. }

//本科生类

01. public class Undergraduate extends Student{
02. public Undergraduate(String name,int[] scores){
03. super(name);
04. this.setType("本科生");
05. this.setScores(scores);
06. }
07. public Grade calculateGrade(){
08. int average;
09. int sum=0;
10. int[] scores;
11. scores=this.getScores();
12. for(int i=0;i{
13. sum+=scores[i];
14. }
15. average=sum/Student.COURSE_COUNT;
16. if(average>=85)
17. return Grade.DISTINCTION;
18. else if(average>=75)
19. return Grade.MERIT;
20. else if(average>=65)
21. return Grade.AVERAGE;
22. else if(average>=60)
23. return Grade.PASS
24. else
25. return Grade.FAIL;
26. }
27. }

//研究生类

01. public class Postgraduate extends Student{
02. public Postgraduate(String name,int[] scores){
03. super(name);
04. this.setType("研究生");
05. this.setScores(scores);
06. }
07. public Grade calculateGrade(){

08. int average;
09. int sum=0;
10. int[] scores;
11. scores=this.getScores();
12. for(int i=0;i=90)
17. return Grade.DISTINCTION;
18. else if(average>=80)
19. return Grade.MERIT;
20. else if(average>=70)
21. return Grade.AVERAGE;
22. else if(average>=60)
23. return Grade.PASS;
24. else
25. return Grade.FAIL;
26. }
27. }

//测试类

01. public class StudentTest {
02. public static void main(String[] args){
03. Student[] s=new Student[10];
04. int[][] scores=new int[10][Student.COURSE_COUNT];
05. for(int i=0;i<5;i++){
06. for(int j=0;jlculateGrade());
11. }
12. for(int i=5;i<10;i++){
13. for(int j=0;jfor(int i=0;i<10;i++){
21. System.out.print(s[i].getName()+"\t");
22. System.out.print(s[i].getType()+"\t");
23. c=s[i].getScores();
24. for(int j=0;jade().getScoreGrade());
28. }
29. }
30. }

6. 应用抽象类和接口编写程序，根据第4题的要求输出本科生及研究生的成绩等级。要求：首先设计一个接口，接口中包含用于计算学生成绩等级的抽象方法，设计两个类分别实现上述接口，这两个类分别表示本科生及研究生的成绩等级标准。其次设计抽象类Student及其两个子类本科生类Undergraduate和研究生类Postgraduate，两个子类分别设置各自的成绩等级计算标准。最后创建测试类进行测试。
//定义接口
01. public interface GradeCalculate {
02. public String getGrade(int[] scores);
03. }

//本科生成绩等级计算标准

01. public class UnderGradeCalculate implements GradeCalculate {
02. public String getGrade(int[] scores){
03. int average;
04. int sum=0;
05. for(int i=0;i}
08. average=sum/Student.COURSE_COUNT;
09. if(average>=85)
10. return "优秀";
11. else if(average>=75)
12. return "良好";
13. else if(average>=65)
14. return "中等";
15. else if(average>=60)
16. return "及格";
17. else
18. return "不及格";
19. }
20. }

//研究生成绩等级计算标准
01. public class PostGradeCalculate implements GradeCalculate {
02. public String getGrade(int[] scores){
03. int average;
04. int sum=0;
05. for(int i=0;i=90)
10. return "优秀";
11. else if(average>=80)
12. return "良好";
13. else if(average>=70)
14. return "中等";
15. else if(average>=60)
16. return "及格";
17. else
18. return "不及格";
19. }
20. }

//抽象类
01. abstract class Student {
02. final static int COURSE_COUNT=3;
03. private String name;
04. private String type;
05. private int[] scores;
06. private String grade;
07. private GradeCalculate criterion;
08. public Student(String name){
09. this.name=name;
10. }
11. public void setName(String name){
12. this.name=name;
13. }
14. public String getName(){
15. return name;
16. }
17. public void setType(String type){
18. this.type=type;
19. }
20. public String getType(){
21. return type;
22. }
23. public void setScores(int[] scores){
24. this.scores=scores;
25. }
26. public int[] getScores(){
27. return scores;
28 }
29. public void setGrade(String grade){
30. this.grade=grade;
31. }
32. public String getGrade(){
33. return grade;
34. }
35. public void setCriterion(GradeCalculate criterion){
36. this.criterion=criterion;
37. }
38. public GradeCalculate getCriterion(){
39. return criterion;
40. }
41. }

//本科生类
01. public class Undergraduate extends Student{
02. public Undergraduate(String name,int[] scores){
03. super(name);
04. this.setType("本科生");
05. this.setScores(scores);
06. this.setCriterion(new UnderGradeCalculate());
07. this.setGrade(this.getCriterion().getGrade(scores));
08. }
09. }

//研究生类
01. public class Postgraduate extends Student{
02. public Postgraduate(String name,int[] scores){
03. super(name);
04. this.setType("研究生");
05. this.setScores(scores);
06. this.setCriterion(new PostGradeCalculate());
07. this.se