java实验报告.docx
《java实验报告.docx》由会员分享，可在线阅读，更多相关《java实验报告.docx（20页珍藏版）》请在冰豆网上搜索。
java实验报告
面向对象程序设计
实验报告
学号：
姓名：
提交日期：
2012-10-14
成绩：
东北大学秦皇岛分校
实验一类与对象
一、实验目的
1．掌握类的声明。
2．掌握对象的创建。
3．掌握方法的定义和调用。
4．掌握构造函数的使用。
二、实验内容
1．编程创建一个Box类，在其中定义三个变量表示一个立方体的长、宽和高，再定义一个方法setDemo对这三个变量进行初始化，然后定义一个方法求立方体的体积。
创建一个对象，求给定尺寸的立方体的体积。
publicclassBox{
doubleheight,width,length;
publicvoidsetDemo（doubleheight,doublewidth,doublelength）{
this.height=height;
this.length=length;
this.width=width;
}
publicdoublegetVolume（）{
returnheight*width*length;
}
}
publicclassLab1_1{
publicstaticvoidmain（String[]args）{
//TODOAuto-generatedmethodstub
Boxbox=newBox（）;
box.setDemo（10,10,10）;
System.out.println（"立方体的体积是：
"+box.getVolume（））;
}
}
2．将上题的方法setDemo改用构造函数实现初始化。
publicclassBox2{
doubleheight,width,length;
Box2（doubleheight,doublewidth,doublelength）{
this.height=height;
this.length=length;
this.width=width;
}
publicdoublegetVolume（）{
returnheight*width*length;
}
}
三、思考题
1．一个方法或一个块内定义的变量是否可以在方法外或块外使用？
这种变量称为什么？
方法的形式参数是否可以在方法之外使用？
答：
不可以在方法外或者块外使用；这种变量称为局部变量；方法的形式参数不可以在方法之外使用。
2．为什么说构造函数是一种特殊的方法？
特殊在哪里？
构造函数什么时候执行？
被谁调用？
答：
在java语言中，构造函数又称构造方法。
特殊性在于，与普通方法的区别是，他与类名相同，不返回结果也不加void返回值。
构造函数的作用是初始化对象，即在创建对象时被系统调用（与普通方法不同，程序不能显示调用构造函数）。
构造函数还能够被重载，即可以传入参数，当程序中包含有带参的构造函数时，系统将不会再提供的无参构造函数。
3．编程创建一个Point类，在其中定义两个变量表示一个点的坐标值，再定义构造函数初始化为坐标原点，然后定义一个方法实现点的移动，再定义一个方法打印当前点的坐标。
并创建一个对象验证。
提示：
关键代码如下：
voidmove（intnewX,intnewY）
{
x=newX;
y=newY;
}
voidprint（）
{
System.out.println（name+":
x="+x+"y="+y）;
}
…
p.print（）;
p.move（50,50）;
System.out.println（"**aftermoving**"）;
p.print（）;//callmethodofanobject
答：
publicclassPoint{
intx,y;
publicPoint（）{
this.x=0;
this.y=0;
}
publicvoidmove（intnewX,intnewY）{
x=newX;
y=newY;
}
publicvoidprint（）{
System.out.println（"横坐标：
"+x+"纵坐标：
"+y）;
}
}
publicclassClass3{
publicstaticvoidmain（String[]args）{
//TODOAuto-generatedmethodstub
Pointp=newPoint（）;
p.move（100,299）;
System.out.println（"**aftermoving**"）;
p.print（）;
}
}
4．定义一个类实现银行帐户的概念，包括的变量有“帐号”和“存款余额”，包括的方法有“存款”、“取款”和“查询余额”。
定义主类，创建帐户类的对象，并完成相应操作。
提示：
关键代码如下：
publicintgetleftmoney（）{
returnleftmoney;
}
publicvoidsavemoney（doublemoney）{
leftmoney+=money;
}
publicvoidgetmoney（doublemoney）{
if（money<=leftmoney）
leftmoney-=money;
else
System.out.println（"只能取：
"+leftmoney）;
}
…
bankaccountba=newbankaccount（123456,1000）;
ba.savemoney（2000）;
System.out.println（"存入2000元后余额为：
"+ba.getleftmoney（））;
ba.getmoney（1500）;
System.out.println（"1500元后余额为：
"+ba.getleftmoney（））;
答：
publicclassBankaccount{
privatedoubleleftmoney;
intpassword;
publicBankaccount（doubleleftmoney,intpassword）{
this.leftmoney=leftmoney;
this.password=password;
}
publicvoidsavemoney（doublemoney）{//存钱
leftmoney+=money;
}
publicvoidgetmoney（doublemoney）{//取钱
if（money<=leftmoney）
leftmoney-=money;
else
System.out.println（"只能取出：
"+leftmoney）;
}
publicdoublegetleftmoney（）{//查询余额
returnleftmoney;
}
}
publicclassClass4{
publicstaticvoidmain（String[]args）{
//TODOAuto-generatedmethodstub
Bankaccountb=newBankaccount（155000,1234567890）;
b.savemoney（1000）;
System.out.println（"存入1000元后余额为：
"+b.getleftmoney（））;
b.getmoney（50000）;
System.out.println（"取出50000后余额为：
"+b.getleftmoney（））;
}
}
实验二继承与多态
一、实验目的
1．掌握类的继承方法。
2．掌握变量的继承和覆盖。
3．掌握方法的继承、重载和覆盖。
4．了解接口的实现方法。
二、实验内容
1．运行下面的程序，理解成员变量的继承与隐藏。
importjava.io.*;
classsum_3{
intsum,num1,num2;
staticintnum3;
//定义构造函数初始化对象
sum_3（）{
num1=0;
num2=0;
num3=0;
sum=0;
}
}
classsub_sum3extendssum_3{
intsum,num1,num2;//隐藏父类sum_3中的实例变量
staticintnum3;//隐藏父类sum_3中的类变量
voidsum（inti,intj,intk）{
num1=i;
num2=j;
num3=k;
sum=num1+num2+num3;
}
}
publicclasscomputing{
publicstaticvoidmain（Stringarg[]）{
sub_sum3m1=newsub_sum3（）;
m1.sum（100,200,300）;
System.out.println（"sum="+m1.num1+"+"+m1.num2+"+"+m1.num3+"="+m1.sum）;
}
}
2．运行下面的程序，理解方法的继承。
classSort3{
doublemax1,max2,max3;
Sort3（）{
max1=-1;
max2=-1;
max3=-1;
}
voidsort（）{
doubles;
if（max1s=max1;max1=max2;max2=s;
}
if（max1s=max1;max1=max3;max3=s;
}
if（max2s=max2;max2=max3;max3=s;
}
}
}
classsub_Sort3extendsSort3{
voidsubsort（doublei,doublej,doublek）{
max1=i;
max2=j;
max3=k;
sort（）;//调用父类中的方法sort（）
}
}
publicclassClass1{
publicstaticvoidmain（Stringargs[]）{
sub_Sort3m1=newsub_Sort3（）;
m1.subsort（100,200,300）;
System.out.println（"三个数从大到小为：
"+m1.max1+","+m1.max2+","+m1.max3）;
}
}
3．运行下面的程序，理解方法的重载。
classSort2or3{
doublemax1,max2,max3;
Sort2or3（）{
max1=-1;
max2=-1;
max3=-1;
}
voidsort（doublei,doublej）{
doubles;
max1=i;
max2=j;
if（max1s=max1;max1=max2;max2=s;
}
}
voidsort（doublei,doublej,doublek）{
doubles;
max1=i;
max2=j;
max3=k;
if（max1s=max1;max1=max2;max2=s;
}
if（max1s=max1;max1=max3;max3=s;
}
if（max2s=max2;max2=max3;max3=s;
}
}
}
publicclassClass1{
publicstaticvoidmain（Stringargs[]）{
Sort2or3m1=newSort2or3（）;
m1.sort（100,200）;
System.out.println（"两个数从大到小为：
"+m1.max1+","+m1.max2）;
m1.sort（50,150,100）;
System.out.println（"三个数从大到小为：
"+m1.max1+","+m1.max2+","+m1.max3）;
}
}
4．运行下面的程序，理解方法的覆盖。
classsort_Demo{
inti,j,k,swap;
sort_Demo（）{
i=j=k=swap=0;
}
voidsort（intt1,intt2[]）{ //父类中的方法用来实现升序
//用选择法按升序排列
for（i=0;ik=i;
for（j=i+1;jif（t2[j]if（k!
=i）{
swap=t2[i];
t2[i]=t2[k];
t2[k]=swap;
}
}
}
}
classsub_sort_Demoextendssort_Demo{
voidsort（intt1,intt2[]）{ //子类中的方法实现降序
//用选择法实现降序排列
for（i=0;ik=i;
for（j=i+1;jif（t2[j]>t2[k]）k=j;
if（k!
=i）{
swap=t2[i];
t2[i]=t2[k];
t2[k]=swap;
}
}
}
}
publicclassClass1{
publicstaticvoidmain（Stringargs[]）{
inta[]={34,12,8,67,88,23,98,101,119,56};
sort_Demom1=newsort_Demo（）;
sub_sort_Demom2=newsub_sort_Demo（）;
System.out.println（"排序前的数据为：
"）;
for（inti=0;i<10;i++）
System.out.print（" "+a[i]）;
//调用父类中的sotr（）方法
m1.sort（a.length,a）;
System.out.println（"\n按升序排列的数据为：
"）;
for（inti=0;i<10;i++）
System.out.print（" "+a[i]）;
//调用子类中的sort（）方法,该方法实现了对父类中方法的覆盖
m2.sort（a.length,a）;
System.out.println（"\n按降序排列的数据为：
"）;
for（inti=0;i<10;i++）
System.out.print（" "+a[i]）;
}
}
5.定义两个接口，其方法协议分别完成两个数的加法和减法操作，然后创建一个类实现这两个接口的方法。
publicinterfacesub{
abstractintsub（inta,intb）;
}
publicinterfaceadd{
abstractintadd（inta,intb）;
}
publicclassshixianimplementsadd,sub{
publicintadd（inta,intb）{
intsum=a+b;
returnsum;
}
publicintsub（inta,intb）{
intsum=a-b;
returnsum;
}
}
publicclassMain{
publicstaticvoidmain（String[]args）{
//TODOAuto-generatedmethodstub
shixians=newshixian（）;
System.out.println（"4+5="+s.add（4,5）+""+"9-3="+s.sub（9,3））;
}
}
三、思考题
1．子类重新定义与父类方法的方法头完全相同的方法，这种情况称为什么？
答：
重写。
2．同名的不同方法共存的情况称为什么？
如何区分这些同名方法？
答：
重载；根据参数的类型和个数来区分。
3．创建一个类，声明一个无参数的构造函数，打印类已创建的信息；再重载一个具有String参数的构造函数，打印参数信息；并创建主类验证之。
publicclasssk3{
sk3（）{
System.out.println（"Hello,world"）;
}
sk3（Strings）{
System.out.println（s）;
}
}
publicclassskmain{
publicstaticvoidmain（String[]args）{
Stringwo="tree";
//TODOAuto-generatedmethodstub
sk3w=newsk3（wo）;
sk3q=newsk3（）;
}
4．定义一个矩形类，再定义接口EqualDiagonal，其中包含方法getDiagonal（）；由矩形类派生出一个正方形类，自行扩充成员变量和方法，并实现此接口EqualDiagonal。
interfaceEqualDiagonal{
doublegetDiagonal（）;
}
publicclassSquarextendsRectangleimplementsEqualDiagonal{
publicdoubleside=0;
publicSquar（doubles）{
super（s,s）;
side=s;
}
publicdoublegetDiagonal（）{
returnMath.sqrt（side*side+side*side）;
}
}
publicclassRectangle{
publicdoubleheight=0;
publicdoublewidth=0;
publicRectangle（doubleh,doublew）{
height=h;
width=w;
}
publicdoublegetArea（）{
returnheight*width;
}
}
publicclassClassr{
publicstaticvoidmain（String[]args）{
Rectanglerect=newRectangle（10.0,20.0）;
Squarsqu=newSquar（20.0）;
System.out.println（"矩形面积为:
"+String.valueOf（rect.getArea（）））;
System.out.println（"正方形面积为:
"+String.valueOf（squ.getDiagonal（）））;
System.out.println（"正方形对角线为:
"+String.valueOf（squ.getDiagonal（）））;
}
}
升级会员 