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()));
}
}