实验二：面向对象编程

   

一、           实验目的

         通过编程和上机实验了解Java语言是如何体现面向对象编程基本思想，熟悉类的封装方法以及如何创建类和对象，熟悉成员变量和成员方法的特性，熟悉类的继承性和多态性的作用，熟悉包、接口的使用方法，掌握OOP方式进行程序设计的方法。

二、           实验要求

1、  编写程序实现类的定义和使用。

2、  编写不同成员和不同成员方法修饰方法的程序。

3、  编写体现类的继承性（成员变量、成员方法、成员变量隐藏）的程序和多态性（成员方法重载、构造方法重载）的程序。

4、  编写接口的定义和使用的程序。

5、  编写包的定义和使用的程序。

三、           实验内容及运行结果

1、 类的定义和使用

l  定义一个满足如下要求的Date类：

a.       用下面的格式输出日期：日/月/年

b.       可运行在日期上加一天操作

c.       设置日期

       用该类编写一个显示当前日期的程序。

l  创建一个桌子Table类，该类中有桌子名称、重量、桌面宽度、长度及桌子高度属性。其中有：

a.       构造函数初始化所有数据成员

b.       Area（）：计算桌面的面积

c.       Display（）：在屏幕上输出所有数据成员的值

d.       ChangeWeight（int ）：改变桌子重量的函数

e.       在main()中实现创建一个桌子对象，计算桌面的面积，改变桌子重量，并在屏幕上输出所有桌子数据成员的值。

源代码：

class Table

{

         private String name;

         private double weight;

         private double width;

         private double length;

         private double height;

         //构造函数

         public Table(String name,double weigth,double width,double length,double height)

         {

                   this.name = name;

                   this.weight = weight;

                   this.width = width;

                   this.length = length;

                   this.height = height;

         }

         //计算桌面的面积

         public double Area()

         {

                   return width*length;

         }

         //在屏幕上输出所有数据成员的值

         public void Display()

         {

                   System.out.println("桌子的名称: "+name+", "+"重量(kg): "+weight);

                   System.out.println("桌面的宽度(cm): "+width+", "+"长度(cm): "+length);

                   System.out.println("桌子的高度(cm): "+height);

         }

         //改变桌子重量的函数

         public void ChangeWeight(double weight)

         {

                   this.weight = weight;

         }

}

class TestTable

{

         public static void main(String[] args)

         {

                   Table t = new Table("桌神",10,100,60,130);

                   //计算桌面的面积

                   System.out.println("桌面的面积为："+t.Area());

                   //改变桌子重量

                   t.ChangeWeight(15);

                   //在屏幕上输出所有桌子数据成员的值

                   t.Display();

         }

}

运行结果：

2、 修饰符的使用：

         有时需要公开一些变量和方法，有时需要禁止其他对象使用变量和方法，这时可以使用修饰符来实现这个目的。常用的修饰符如下：public、private、protected、package、static、final、transient、volatile

l  程序功能：通过两个类StaticDemo、TestDemo说明静态变量/方法与实例变量/方法的区别，程序源代码如下：

class StaticDemo

{

static int x;

int y;

public static int getX()

{

           return x;

}

public static void setX(int newX)

{

           x = newX;

}

public int getY()

{

           return y;

}

public void setY(int newY)

{

           y = newY;

}

}

public class TestDemo

{

public static void main(String[] args)

{

           System.out.println("静态变量x="+StaticDemo.getX());

           System.out.println("实例变量y="+StaticDemo.getY());//非法，编译时将出错

           StaticDemo a = new StaticDemo();

           StaticDemo b = new StaticDemo();

           a.setX(1);

           a.setY(2);

           b.setX(3);

           b.setY(4);

           System.out.println("静态变量a.x="+a.getX());

           System.out.println("静态变量a.y="+a.getY());

           System.out.println("静态变量b.x="+b.getX());

           System.out.println("静态变量b.y="+b.getY());

}

}

运行结果：

3、 继承和多态的作用

新类可从现有的类中产生并保留现有类的成员变量和方法，并可根据需要对它们加以修改。新类还可添加新的变量和方法，这种现象就称为类的继承。当建立一个新类时，不必写出全部成员变量和成员方法。只要简单地声明这个类是从一个已定义的类继承下来的，就可以引用被继承类的全部成员。被继承的类称为父类或超类( superclass)，这个新类称为子类。

    Java提供了一个庞大的类库让开发人员继承和使用。设计这些类是出于公用的目的，因此，很少有某个类恰恰满足你的需要。你必须设计自己的能处理实际问题的类，如果你设计的这个类仅仅实现了继承，则和父类毫无两样。所以，通常要对子类进行扩展，即添加新的属性和方法。这使得子类要比父类大，但更具特殊性，代表着一组更具体的对象。继承的意义就在于此。

    类的继承发生在多个类之间，而类的多态只发生在同一个类上。在一个类中，可以定义多个同名的方法，只要确定它们的参数个数和类型不同。这种现象称为类的多态。多态使程序简洁，为程序员带来很大便利。在OOP中，当程序要实现多个相近的功能时，就给相应的方法起一个共同的名字，用不同的参数代表不同的功能。这样，在使用方法时不论传递什么参数，只要能被程序识别就可以得到确定的结果。类的多态性体现在方法的重载( overload)上，包括成员方法和构造方法的重载。

l  创建Rodent（啮齿动物）：Mouse（老鼠），Gerbil（沙鼠），Hamster（大颊鼠）等的一个继承分级结构。在基础类中，提供适用于所有Rodent的方法，并在衍生类中覆盖它们，从而根据不同类型的Rodent采取不同的行动。创建一个Rodent数组，在其中填充不同类型的Rodent，然后调用自己的基础类方法，看看会有什么情况发生。

源程序：

class Rodent//基础类

{

void nightAction(){

           System.out.println("Rodent.nightAction()");

}

}

class Mouse extends Rodent//老鼠类

{

           void nightAction(){

                    System.out.println("Mouse.nightAction()");

           }

}

class Gerbil extends Rodent//沙鼠类

{

           void nightAction(){

                    System.out.println("Gerbil.nightAction()");

           }

}

class Hamster extends Rodent

{

           void nightAction(){

                    System.out.println("Hamster.nightAction()");

           }

}

//测试类

public class RodentTest

{

           public static void main(String[] args){

                    Rodent[] rt = new Rodent[4];//创建一个Rodent数组

                    rt[0] = new Rodent();

                    rt[1] = new Mouse();

                    rt[2] = new Gerbil();

                    rt[3] = new Hamster();

                    for(Rodent rodent:rt){

                             rodent.nightAction();

                    }

           }

}

         运行结果：

4、 接口的定义和使用

Java中的接口在语法上有些类似于类，它定义了若干的抽象方法和常量，形成一个属性集合，该属性集合通常代表了某一功能的实现。它的主要作用是可以帮助我们实现类似于类的多重继承的功能。Java中各类获取某一接口定义的功能，并不是通过直接继承这个接口中的域和方法来实现的，因为接口中的域都是常量，接口中的方法都是没有方法体的抽象方法，也就是说，接口定义的仅仅是实现某一特定功能的功能接口和规范，而并没有真正的实现这个功能，这个功能的真正实现实在“继承”了这个接口的各个类中完成的，有这些类来具体定义接口中各抽象方法的方法体。故在Java中，通常把对接口功能的“继承”称为实现。

 Java中声明接口的语法如下：

    [public] Interface接口名[extends父接口名列表]

    {    //接口体：

              //常量域声明

        [public] [static] [final]域类型  域名=常量值；

              //抽象方法声明

              [public] [abstract] [native]返回值方法名（参数列表）[throw异常列表]；

    }

某个类为接口中的抽象方法书写语句并定义实在的方法体，称为该类实现可这个接口。

● 程序如下：

    public class InterfaceTest

{

    public static void main(String args[])

    {        double x;

    circle y=new circle(2);

    //y.cirdle(2);

    x=y.calculate_atea();

    System.out.println( "面积为:"+x);

    }

    }

    interface cal_area

    {

    double PI=3.14;

              public double calculate_atea();

    }

class circle implements cal_area

{

      double r;

    circle(double r)

{

          this.r=r;

    }

public double calculate_atea()

{

          return PI*r*r;

    }

}● 编译并运行上述程序。

5、 包的定义和使用

●创建自定义包Mypackage

在存放源程序的文件夹中建立一个子文件夹Mypackage。例如，在“E:\java\程序”文件夹之中创建一个与包同名的子文件夹Mypackage(E:java程序\Mypackage)，并将编译过的class文件放入该文件夹中。注意：包名与文件夹名大小写要一致。再添加环境变量classpath的路径，例如：E:\j2sdkl.4.2_01\lib;E:\java\程序

● 在包中创建类

YMD.java程序功能：在源程序中，首先声明使用的包名Mypackage，然后创建YMD类，该类具有计算今年的年份并输出一个带有年月日的字符串的功能。源代码如下

    package Mypackage;    //声明存放类的包

import java.util.*;    //引用java.util包

public class Test_YMD

{

    private int year,month, day;

    public static void main(String[] arg3)

{}

    public Test_YMD(int y, int m, int d)

{

    year=y;

    month=(((m>=1)&(m<=12))?m:1);

    day=(((d>=1)&(d<=31))?d:1);

    }

      public Test_YMD()

{

    this(0,0,0);

    }

    public static int thisyear()

{

    return Calendar.getInstance().get(Calendar.YEAR);//返回当年的年份

    }

    public int year()

{

    return year;//返回年份

    }

    public String toString()

{

    return year+"-"+month+"-"+day;//返回转化为字符串的年-月-日

    }

}    编译Test_YMD.java文件，然后将Test_ YMD.class文件存放到Mypackage文件夹

●  编写使用包Mypackage中Test_YMD类的程序

YMD_2.java程序功能：给定某人姓名与出生日期，计算该人年龄，并输出该人姓名，年龄，出生日期。程序使用了Test_YMD的方法来计算年龄。源代码如下:

  import Mypackage.Test_YMD;//引用Mypackage包中的Test_YMD类

public class YMD_2

{

    private String name;

    private Test_YMD birth;

    public static void main(String args[])

    {

    YMD_2 a=new YMD_2("白若男",1990,1,11);

    a.output();

    }

    public YMD_2(String n1,Test_YMD d1)

    {

    name=n1;

    birth=d1;

    }

      public YMD_2(String n1,int y,int m,int d)

    {

    this(n1,new Test_YMD(y,m,d));//初始化变量与对象

    }

        public int age()    //计算年龄

    {

    return Test_YMD.thisyear()-birth.year();//返回当前年与出生年的差即年龄

    }

    public void output()

    {

    System.out.println("姓名："+name);

    System. out.println("出生日期："+birth.toString());

    System. out.println("今年年龄:"+age());

    }

  }编译并运行程序。

 

第二篇：java实验二实验报告模板

实验二:java程序设计

一、实验目的与要求

1、了解Java 的数据类型；

2、掌握各种变量的声明方式；

3、理解运算符的优先级；

4、掌握Java 基本数据类型、运算符与表达式、数组的使用方法；

5、理解Java 程序语法结构，掌握顺序结构、选择结构和循环结构语法的程序设计方法；

6、通过以上内容，掌握Java 语言的编程规则。

二、实验内容

读入一个浮点数值，将其转换为中文金额的大写方式，如123.45,转换为:壹佰贰拾叁元肆角伍分。要求：

（1）当金额为整数时，只表示整数部分，省略小数部分，并添加“整”字。例如，123表示为:壹佰贰拾叁元整；

（2）当金额中含有连续的0时，只需写一个“零”即可，例如， 10005表示为：壹万零伍元整；

（3）10的表示方式，例如，110元表示为：壹佰壹拾元整，而10则表示为：拾元整。 提示：将字符串型转换为浮点型可以用Float.parseFloat(s)函数转换。

三、实验器材

微机+windows操作系统+eclipse

四、实验步骤

1、程序代码

import java.io.*;

import java.util.Scanner;

public class ee {

/** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub /** * 数据输入 */ System.out.println("请输入一个实数"); InputStream is=System.in; Scanner scan=new Scanner(is); float y=scan.nextFloat(); System.out.println("y="+y); float x=y; int ix=(int)x;//整数部分

float px=x-ix;//小数部分 String cx=ix+""; String cy=px+""; /** * 处理整数部分,采用二进制转换思想 */ int []zhengshu=new int[cx.length()]; int i=0; if(cx.length()<=4) { } /** * 整数钱币输出 */ for(int ii=cx.length()-1;ii>=0;ii--) { if(zhengshu[ii]==0) { if(ii!=0) { } if(ii==0) { System.out.print("圆"); if(zhengshu[ii-1]!=0) { System.out.println("零"); } while(ix>0) { } zhengshu[i]=ix-ix/10*10;//求出余数，并赋给数组zhengshu i++; ix=ix/10;//商

}

}

if(zhengshu[ii]!=0) { if(ii==3) { if(zhengshu[ii]==1) System.out.print("壹仟"); if(zhengshu[ii]==2) System. if(zhengshu[ii]==3) System. if(zhengshu[ii]==4) System. if(zhengshu[ii]==5) System. if(zhengshu[ii]==6) System. if(zhengshu[ii]==7) System.

if(zhengshu[ii]==8) System. if(zhengshu[ii]==9) System. }

if(ii==2) { if(zhengshu[ii]==1) System. if(zhengshu[ii]==2) System. if(zhengshu[ii]==3) System. if(zhengshu[ii]==4) System. if(zhengshu[ii]==5) System. if(zhengshu[ii]==6) System. if(zhengshu[ii]==7) System.

if(zhengshu[ii]==8) System. if(zhengshu[ii]==9) System. }

if(ii==1) { if(zhengshu[ii]==1) System. if(zhengshu[ii]==2) System. if(zhengshu[ii]==3) System. if(zhengshu[ii]==4) System. if(zhengshu[ii]==5) System. if(zhengshu[ii]==6) System. if(zhengshu[ii]==7) System.

if(zhengshu[ii]==8) System. if(zhengshu[ii]==9) System. }

if(ii==0)

{

out.print("贰仟"); out.print("叁仟"); out.print("肆仟"); out.print("伍仟"); out.print("陆仟"); out.print("柒仟"); out.print("捌仟");

out.print("玖仟"); out.print("壹佰"); out.print("贰佰"); out.print("叁佰"); out.print("肆佰"); out.print("伍佰"); out.print("陆佰"); out.print("柒佰"); out.print("捌佰");

out.print("玖佰"); out.print("壹拾"); out.print("贰拾"); out.print("叁拾"); out.print("肆拾"); out.print("伍拾"); out.print("陆拾"); out.print("柒拾"); out.print("捌拾");

out.print("玖拾");

} if(zhengshu[ii]==1) System.out.print("壹圆"); if(zhengshu[ii]==2) System.out.print("贰圆"); if(zhengshu[ii]==3) System.out.print("叁圆"); if(zhengshu[ii]==4) System.out.print("肆圆"); if(zhengshu[ii]==5) System.out.print("伍圆"); if(zhengshu[ii]==6) System.out.print("陆圆"); if(zhengshu[ii]==7) System.out.print("柒圆"); if(zhengshu[ii]==8) System.out.print("捌圆"); if(zhengshu[ii]==9) System.out.print("玖圆"); } } /** * 处理小数部分 */ float yushu; int xiaoshu[]=new int[2]; xiaoshu[0]=(int)(px*10); yushu=px*10-xiaoshu[0]; xiaoshu[1]=(int)(yushu*10); if(xiaoshu[0]!=0) { if(xiaoshu[0]==1) System.out.print("壹角"); if(xiaoshu[0]==2) System.out.print("贰角"); if(xiaoshu[0]==3) System.out.print("叁角"); if(xiaoshu[0]==4) System.out.print("肆角"); if(xiaoshu[0]==5) System.out.print("伍角"); if(xiaoshu[0]==6) System.out.print("陆角"); if(xiaoshu[0]==7) System.out.print("柒角"); if(xiaoshu[0]==8) System.out.print("捌角"); if(xiaoshu[0]==9) System.out.print("玖角"); } else { } if(xiaoshu[1]!=0) { if(xiaoshu[0]==0) { } if(xiaoshu[1]!=0) System.out.println("零");

} } if(xiaoshu[1]==1) System.out.print("壹分"); if(xiaoshu[1]==2) System.out.print("贰分"); if(xiaoshu[1]==3) System.out.print("叁分"); if(xiaoshu[1]==4) System.out.print("肆分"); if(xiaoshu[1]==5) System.out.print("伍分"); if(xiaoshu[1]==6) System.out.print("陆分"); if(xiaoshu[1]==7) System.out.print("柒分"); if(xiaoshu[1]==8) System.out.print("捌分"); if(xiaoshu[1]==9) System.out.print("玖分"); }

五、实验结果

请输入一个实数

34.678

y=34.678

叁拾肆圆陆角柒分

请输入一个实数

123.23

y=123.23

壹佰贰拾叁圆贰角叁分

请输入一个实数

110.00

y=110.0

壹佰壹拾圆

六、实验小结

1、通过这个实验巩固了java的基础知识：包括数据类型、变量的声明方式、运算符的优先级、表达式的应用、数组的使用。

2、熟练了程序的控制结构：顺序结构、选择结构和循环结构，并在实验中得以使用。

3、了解了java的编程规则。

4、综合应用所学知识完成java程序的分析、设计、调试和总结；为以后编写更复杂的java程序打下了很好的基础。