Java实验三参考答案(昆工版本).doc

昆明理工大学信息工程与自动化学院学生实验报告
（ 2012—2013学年 第 一 学期 ）
课程名称：java程序设计 开课实验室：信自445 2012年 11月 21 日
年级、专业、班
计科11
学号

姓名
苏东博，狄家帆，张盼
成绩
95
实验项目名称
Java面向对象程序设计
指导教师
张晓丽
教师评语
复习题仔细查看并掌握；编程题可参考书提供的源代码。
教师签名：
年 月 日
一、实验目的及内容
目的：掌握Java中面向对象的思想，类和对象的应用，可见性修饰符，数据域的封装，静态变量和方法，给方法传递对象参数。
内容：完成下面要求的程序和习题
（一）．复习题
1． 课本P234第八章复习题8.12，给出正确的程序并显示结果，分析错误问题；
2． 课本P235第八章复习题8.16，显示并分析结果；
3． 课本P235第八章复习题8.17，显示并分析结果；
4． 课本P236第八章复习题8.18，显示并分析结果；
5． 课本P236第八章复习题8.19，显示并分析结果；
6． 课本P237第八章复习题8.20，给出正确的程序并显示结果，分析错误问题；
（二）．编程题
1． 课本P238第八章编程题8.4（使用Random 类，参考jdk_7_docs.api，）
注：通俗说，两者的区别是：带种子的，每次运行生成的结果都是一样的。 不带种子的，每次　运行生成的都是随机的，没有规律可言。
2． 课本p23８第八章编程练习题8.７（账户类）；
注：月利率＝balance * (annualInterestRate / 12)
3． 课本p23９第八章编程练习题8.９（正ｎ边形）
注：面积公式错误：p->PI；则JAVA编程公式：n*side*side/(4*Math.tan(Math.PI/n)
访问器getter和修改器setter，在eclipse中可自动生成（eclipse中source菜单\Generate getter and setter）
4． 完成并掌握每章课后复习题，上课提问检查；
5． 每章其他编程练习题；（选作）
二、要求（编程题中给出实验内容的程序设计、实现和结果，并对结果进行分析。）
（一） ．复习题
1. 课本P234第八章复习题8.12，给出正确的程序并显示结果，分析错误问题；
分析：不能从静态方法中直接调用一个实例方法或引用实例变量，须实例化对象后，通过该对象调用实例方法或变量；但可以从一个实例方法中调用一个静态方法或引用一个静态变量。
正确程序1:
public class Foo {
public static void main(String[] args) {
method1();
}
public static void method1()
{
method2();}
public static void method2(){
System.out.println("What is radius"+ c.getRadius());
}
static Circle c=new Circle();
}

class Circle{
static double radius;
static double getRadius(){
radius=1;
return radius;
}
}

正确程序2:
public class Be8_12 {
/*不能从静态方法中直接调用一个实例方法或引用实例变量，
* 须实例化对象后，通过该对象调用实例方法或变量
*但可以从一个实例方法中调用一个静态方法或引用一个静态变量。*/
public static void main(String[] args) {
new Be8_12().method1();
}
public void method1(){
method2();
}

public static void method2(){
Circle c=new Circle();//注须将Circle.java源程序放在同一包p8中，或import p8.Circle；且Circle 类中须有getRadius 方法：
public double getRadius() {
return r;
}
System.out.println("what is radius "+c.getRadius());
//new Be8_12().method1();//须实例化对象后，通过该对象调用实例方法或变量
}

}
大多数错误程序 ：public class Foo{
public static void main(String[] args) {
method1();
}
public static void method1(){
method2();
}
double radius;
//错误：不在Circle类中如何能定义该构造函数。
Circle(){
radius=5.0;
}
Circle (double newRadius){
radius=newRadius;
}
public static void method2(){
Circle c=new Circle();
System.out.println("what is radius "+c.getRadius());
}
double getRadius(){
return radius;}
}
结果显示：
what is radius 1.0//注1.0由无参构造函数Circle()决定

2.课本P235第八章复习题8.16，显示并分析结果；
分析 ：传递基本类型参数，传递的是实参的值，实参的值不会改变；
传递引用类型参数，传递的是对象的引用，可以改变实参的值。

程序：public class Test{
public static void main(String[] args){
Count myCount=new Count();
int times=0;
for(int i=0;i<100;i++)
increment(myCount,times);
System.out.println("count is "+myCount.count);
System.out.println("times is "+times);
}
public static void increment(Count c,int times){
c.count++; times++;
}
}
class Count{
public int count;
public Count(int c){
count=c;
}
public Count(){
count=1;
}
}
结果显示：

3.课本P235第八章复习题8.17，显示并分析结果；
分析 ：第三四行分别创建了半径为1和2的两个对象circle1和circle2；
然后分别调用swap1()和swap2()函数，并输出两个对象的半径；
在swap1（）函数对地址值交换，但未影响对象，值未做交换；
在swap2（）函数中两个对象的半径在内存里交换了，值成功交换；
程序： public class Be8_17 {

public static void main(String[] args) {
Circle3 circle1 = new Circle3(1);
Circle3 circle2 = new Circle3(2);
swap1(circle1, circle2);
System.out.println("After swap1: circle1=" + circle1.radius
+ " circle2=" + circle2.radius);
swap2(circle1, circle2);
System.out.println("After swap2: circle1=" + circle1.radius
+ " circle2=" + circle2.radius);
}

public static void swap1(Circle3 x, Circle3 y) {
Circle3 temp = x;
x = y;
y = temp;
}

public static void swap2(Circle3 x, Circle3 y) {
double temp = x.radius;
x.radius = y.radius;
y.radius = temp;
}
}

class Circle3 {
double radius;

Circle3(double newRadius) {
radius = newRadius;
}

}
}
结果显示：

4.课本P236第八章复习题8.18，显示并分析结果；
分析 ：①Swap方法实现了两个形参的交换，但是未能改变实参-数组元素的值。即在调用swap函数的时候把a[0]a[1]的值1,2传给了n1,n2在swap()函数中只调换了n1,n2的位置，但并没有调换a[0]和a[1]的值,所以输出结果仍然为a[0]=1,a[1]=2
程序： ①public class fuxiti{
public static void main(String[] args) {
int[] a={1,2};
swap(a[0],a[1]);
System.out.println("a[0]= "+a[0]+" a[1]="+a[1]);
}
public static void swap(int n1,int n2){
int temp=n1;
n1=n2;
n2=temp;
}
}
结果显示

② Swap方法利用传递数组的方式来实现了两个数据的交换，Swap方法将a[0]a[1]做了交换
②public class fuxiti{
public static void main(String[] args) {
int[] a={1,2};
swap(a);
System.out.println("a[0]="+a[0]+" a[1]="+a[1]);
}
public static void swap(int[] a){
int temp=a[0];
a[0]=a[1];
a[1]=temp;
}
}

③传递一个实例化对象到swap方法中，实现了e1,e2值的交换
③public class fuxiti{
public static void main(String[] args) {
T t=new T();
swap(t);
System.out.println("e1="+t.e1+" e2="+t.e2);
}
public static void swap(T t){
int temp=t.e1;
t.e1=t.e2;
t.e2=temp;
}}
class T{
int e1=1;
int e2=2;
}
结果显示：

④静态变量i将变量值存储在一个公共的内存地址，所以任何对象对此变量的值修改，都会使同一类的所有对象都受到影响。对象t1的实例化使i的值从0加到1，对象t2的实例化使i的值从1加到2，此时i的输出结果就是2.
④public class fuxiti{
public static void main(String[] args) {
T t1=new T();
T t2=new T();
System.out.println("t1's i="+t1.i+" and j="+t1.j);
System.out.println("t2's i="+t2.i+" and j="+t2.j);
}
}
class T{
static int i=0;
int j=0;
T(){
i++;
j=1;
}
}
结果显示：

5.课本P236第八章复习题8.19，显示并分析结果；
A代码：
import java.util.Date;
public class Test
{
public static void main(String[] args)
{
Date date=null;
m1(date);
System.out.println(date);
}
public static void m1(Date date)
{
date=new Date();
}
}

截图：
结果分析：
给对象date赋初值为null的，调用函数m1,只给形参（局部变量）赋值当前时间，可m1无返回值，对象date依然为null。

B代码：
import java.util.Date;
public class Test
{
public static void main(String[] args)
{
Date date=new Date(1234567);
m1(date);
System.out.println(date.getTime());
}
public static void m1(Date date)
{
date=new Date(7654321);
}
}

截图：
结果分析：
给对象date赋初值，调用函数m1,只给形参（局部变量）赋值，可m1无返回值，对象date依然为原值，所以还是原先实例的值。

C代码：
import java.util.Date;
public class Test
{
public static void main(String[] args)
{
Date date=new Date(1234567);
m1(date);
System.out.println(date.getTime());
}
public static void m1(Date date)
{
date.setTime(7654321);
}
}

截图：
结果分析：
给对象date赋初值，调用函数m1,后来利用date的修改器setTime来修改了date值为7654321。

D代码：
import java.util.Date;
public class Test
{
public static void main(String[] args)
{
Date date=new Date(1234567);
m1(date);
System.out.println(date.getTime());
}
public static void m1(Date date)
{
date=null;
}
}

截图：
结果分析：
给对象date赋初值，调用函数m1,只给形参（局部变量）赋null值，可m1无返回值，对象date依然为原值，所以还是原先实例的值。

6.课本P237第八章复习题8.20，给出正确的程序并显示结果，分析错误问题；
原出错程序
public class BE8_20 {
public static void main(String[] args) {
java.util.Date[] dates = new java.util.Date[10];//只给date数组分配了空间，未赋初值，均为Null。
System.out.println(dates[0]);//date[0]为null
System.out.println(dates[0].toString());//toString是把date对象的时间转换为字符串，遭遇空指针异常，提示NullPointerException.
}
}
正确程序1：import java.util.Date;
public class fuxiti{
public static void main(String[] args) {
java.util.Date dates=new java.util.Date();//用普通变量代替数组，并赋初值
System.out.println(dates);
System.out.println(dates.toString());
}
}
正确程序2：

public class Test {
public static void main(String[] args) {
java.util.Date[] dates=new java.util.Date[10];
for(int i=0;i<10;i++){
dates[i]=new java.util.Date();//为数组的每个元素赋初值
}
System.out.println(dates[0]);
System.out.println(dates[0].toString());
}
}

结果显示：

（二）．编程题
1.课本P238第八章编程题8.4（使用Random 类，参考jdk_7_docs.api，）
注：通俗说，两者的区别是：带种子的，每次运行生成的结果都是一样的。 不带种子的，每次运行生成的都是随机的，没有规律可言。
(1) 程序：
public class Random8_4 {
/**
* E8-4使用随机类，种子1000
* 通俗说，两者的区别是：带种子的，每次运行生成的结果都是一样的。
* 不带种子的，每次运行生成的都是随机的，没有规律可言。
*/
public static void main(String[] args) {
Random rd = new Random(1000);
for(int i=0;i<50;i++){
System.out.print(rd.nextInt(100)+" , ");
//nextInt(n)返回一个伪随机数，它是从此随机数生成器的序列中取出的、在 0（包括）和指定值（不包括）之间均匀分布的 int值
}
}
}
(2) 运行截图：

2.课本p23８第八章编程练习题8.７（账户类）；注：月利率＝balance * (annualInterestRate / 12)
(1) 程序：
import java.util.Scanner;
public class Account {
private int id=0;
private double balance=0;
private double annualInterestRate=0;
private java.util.Date dateCreated;

public int getId() {return id;}
public void setId(int id) {
System.out.print("请输入账户ID ： ");
this.id = input.nextInt();
}

public double getBalance() {return balance;}
public void setBalance(double balance) {
System.out.print("请设置您的账户余额 ： ");
this.balance = input.nextDouble();
}

public double getAnnualInterestRate() {return annualInterestRate;}
public void setAnnualInterestRate(double annualInterestRate) {
System.out.print("请输入年利率 ： ");
this.annualInterestRate =input.nextDouble();
}

Scanner input=new Scanner(System.in);
public double getMonthlyInterestRate(){
double MonthlyInterestRate=balance*(annualInterestRate/12);
return MonthlyInterestRate;
}

public java.util.Date getDateCreated() {
return dateCreated;
}

public void setDateCreated(java.util.Date dateCreated) {
this.dateCreated =new java.util.Date();
}
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
int a,b;
Account account1=new Account();
System.out.println("\n\t\t\t所创建的第一个账户的账户信息：");
System.out.println("账户ID ："+account1.id+"\t账户余额 ："+account1.balance+"\t 年利率 ："+account1.annualInterestRate+"\t开户时间 ："+account1.dateCreated);
do{
System.out.print("请选择业务 ：1.存款；2.取款！3.修改器 ");
a=input.nextInt();
if(a==1){
account1.deposit();
System.out.println("月利息为 "+account1.getMonthlyInterestRate()+"\t此 账户开户时间为 "+account1.dateCreated);
}
if(a==2){
account1.withDraw();
System.out.println("月利息为 "+account1.getMonthlyInterestRate()+"\t此 账户开户时间为 "+account1.dateCreated);
}
if(a==3){
account1.setId(a);
account1.setBalance(a);
account1.setAnnualInterestRate(a);
account1.setDateCreated(null);
System.out.println("\t\t\t您新建的账户信息 :");
System.out.println("账户ID ："+account1.id+"\t账户余额 ： "+account1.balance+"\t年利率 ："+account1.annualInterestRate
+"\t开户时间 ："+account1.dateCreated);
}
System.out.print("请选择是否继续 ：若继续请选择 '1'!!");
b=input.nextInt();
if(b!=1)
System.out.println("谢谢使用，祝您愉快!!");
}while(b==1);
}
Account(){
id=1122;balance=20000;annualInterestRate=0.045;dateCreated=new java.util.Date();
}
Account(int newid,double newbalance,double newannualInterestRate){
id=newid;balance=newbalance;annualInterestRate=newannualInterestRate;
}
public double withDraw(){
System.out.print("请输入您的取款金额 ： ");
double withDraw=input.nextDouble();
balance-=withDraw;
System.out.print("尊敬的用户，您成功取款 "+withDraw+"美元!!"+ " 您目前的 余额为 "+balance+"美元!! ");
return balance;
}
public double deposit(){
System.out.print("请输入您的存款金额 ： ");
double deposit=input.nextDouble();
balance+=deposit;
System.out.print("尊敬的用户，您成功存款 "+deposit+"美元!!"+ " 您目前的 余额为 "+balance+"美元!! ");
return balance;
}
}
(2) 运行截图：

3.课本p23９第八章编程练习题8.９（正ｎ边形）
注：面积公式错误：p->PI；则JAVA编程公式：n*side*side/(4*Math.tan(Math.PI/n)
访问器getter和修改器setter，在eclipse中可自动生成（eclipse中source菜单\Generate getter and setter）
(1)程序：
public class RegularPolygon {
private int n=3;
private double side=1;
private double x=0,y=0;

public int getN() {return n;}
public void setN(int n) {
this.n = n;
}

public double getSide() {return side;}
public void setSide(double side) {
this.side = side;
}

public double getX() {return x;}
public void setX(double x) {
this.x = x;
}

public double getY() {return y;}
public void setY(double y) {
this.y = y;
}

public static void main(String[] args) {
RegularPolygon one=new RegularPolygon();
System.out.println("1.默认多边形为边长为 "+one.side+"的"+one.n+"边形"+"\n 此多边形的周长为 :"+one.
getPerimeter()+"\n 此多边形的面积为 :"+one.getArea());
RegularPolygon two=new RegularPolygon(6,4);
two.setN(6);
two.setSide(4);
System.out.println("2.此多边形是以("+two.x+","+two.y+")为中心点，边长为 "+two.side+"的"+two.n+"边形"+"\n 此多边形的周长为 :"+two.
getPerimeter()+"\n 此多边形的面积为 :"+two.getArea());
RegularPolygon three=new RegularPolygon(10,4,5.6,7.8);
three.setN(10);
three.setSide(4);
three.setX(5.6);
three.setY(7.8);
System.out.println("3.此多边形是以("+three.x+","+three.y+")为中心点，边长为 "+three.side+"的"+three.n+"边形"+"\n 此多边形的周长为 :"+three.
getPerimeter()+"\n 此多边形的面积为 :"+three.getArea());
}
RegularPolygon(){
}
RegularPolygon(int n,double side){
n=6;side=4;
}
RegularPolygon(int n,double side,double x,double y){
x=10;side=4;x=5.6;y=7.8;
}

public double getPerimeter(){
return side*n;
}
public double getArea(){
return n*side*side/(4*Math.tan(Math.PI/n));
}
}
(2) 运行截图

4. 完成并掌握每章课后复习题，上课提问检查
复习题已做在课本上
5. 每章其他编程练习题；（选作）
①程序 ：
public class choose1 {
public static void main(String[] args) {
Fan1 fan1 = new Fan1();
fan1.setSpeed(Fan1.FAST);
fan1.setRadius(10);
fan1.setColor("yellow");
fan1.setOn(true);
System.out.println(fan1.toString());

Fan1 fan2 = new Fan1();
fan2.setSpeed(Fan1.MEDIUM);
fan2.setRadius(5);
fan2.setColor("blue");
fan2.setOn(false);
System.out.println(fan2.toString());
}
}
class Fan1 {
public static int SLOW = 1;
public static int MEDIUM = 2;
public static int FAST = 3;
private int speed = SLOW;
private boolean on = false;
private double radius = 5;
private String color = "white";
public Fan1() {
}
public int getSpeed() {
return speed;
}
public void setSpeed(int newSpeed) {
speed = newSpeed;
}
public boolean isOn() {
return on;
}
public void setOn(boolean trueOrFalse) {
this.on = trueOrFalse;
}
public double getRadius() {
return radius;
}
public void setRadius(double newRadius) {
radius = newRadius;
}
public String getColor() {
return color;
}
public void setColor(String newColor) {
color = newColor;