2020-10-19 10:54 武汉科技大学 Java

关注

类的多态性

一、实验目的：

理解类的多态性，掌握方法的继承、重载和覆盖，掌握如何从键盘输入数据以及多重循环的使用。

二、实验环境：

eclipse

三、实验内容：

（一）类的多态性练习

1．理解类的多态性

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

类的多态性体现在方法的重载（overload）上，包括成员方法和构造方法的重载。

2．方法的重载

方法的重载是指对同名方法的不同使用方式。

1) 程序功能：对不同的数进行排序输出。在IntSort 类中定义2 个同名的方法sort。

2) 编写KY5_1.java 文件，源代码如下。

class IntSort {

    public String sort (int a, int b) {

        if (a>b)

            return a+" "+b;

        else

            return b+" "+a;

    }

    public String sort (int a, int b, int c) {  

        int swap;

        if (a<b) {

            swap=a;

            a=b;

            b=swap;

        }

        if (a<c) {

            swap=a;

            a=c;

            c=swap;

        }

        if (b<c) {

            swap=b;

            b=c;

            c=swap;

        }

        return a+" "+b+" "+c;

    }

}



public class KY5_1 {

    public static void main(String args[]) {

        int a=30, b=12, c=40;

        IntSort s=new IntSort();

        System.out.println("两个数的排序结果："+s.sort(a,b));

        System.out.println("三个数的排序结果："+s.sort(a,b,c));

    }

}

3) 编译KY5_1.java并运行程序

4) 将程序的输出结果记录在实验报告中。

输出结果：

5) 请在实验报告中说明在IntSort 类中出现的下面两个同名的方法各自的功能？

I. public String sort (int a, intb)

II. public String sort (int a, intb, int c)

答：public String sort (int a, int b)的功能是对两个数a,b进行由大到小排序。

public Stringsort (int a, int b, int c)的功能是对a,b,c三个数进行由大到小的排序。

6）请在实验报告中指出程序中是哪条语句调用了方法I，哪条语句调用了方法II？

语句：System.out.println("两个数的排序结果："+s.sort(a,b));调用了方法I。

语句：System.out.println("三个数的排序结果："+s.sort(a,b,c));调用了方法II。

（二）构造方法的重载

构造方法的名称和类同名，没有返回类型。尽管构造方法看起来和一般的成员方法没有差别，但它不是方法，也不是类的成员。因此，构造方法不能直接调用，只能由new 操作符调用。

构造方法对于类是十分重要的，对象的初始化任务要靠构造方法来完成。重载构造方法的目的是提供多种初始化对象的能力，使程序员可以根据实际需要选用合适的构造方法来初始化对象。

1) 编写程序KY5_2.java，将其中的类RunDemo的构造方法进行重载。源代码如下。

class RunDemo {

    private String userName, password;

    RunDemo(String name) {

        userName=name;

    }

    RunDemo(String name, String pwd) {

        this(name);

        password=pwd;

    }

    void check() {   //检验用户名和密码

        String s=null;

        if (userName!=null)

            s="用户名："+userName;

        else

            s="用户名不能为空！";

        if (password!="123456")

            s=s+" 口令无效！";

        else

            s=s+" 口令：******";

        System.out.println(s);

    }

}

public class KY5_2 {

    public static void main(String[] args) {

        RunDemo r1=new RunDemo("刘新宇");

        r1.check();

        RunDemo r2=new RunDemo(null, "654321");

        r2.check();

        RunDemo r3=new RunDemo("张驰","123456");

        r3.check();

    }

}

2) 编译程序KY5_2.java并运行程序

3) 将程序的输出结果记录在实验报告中。

输出结果：

4) 指出程序中的下面三条语句分别调用了类RunDemo中的哪个构造方法？

I. new RunDemo("刘新宇");

II. new RunDemo(null,"654321");

III. new RunDemo("张驰","12345678");

答：new RunDemo("刘新宇");调用了构造方法RunDemo(String name) {userName=name; }

new RunDemo(null, "654321"); 调用了构造方法RunDemo(String name, Stringpwd) {

this(name);

password=pwd;}

new RunDemo("张驰","12345678");调用了构造方法unDemo(String name, String pwd) {

this(name);

password=pwd;}

5) 类RunDemo中有两个构造方法，其中第一个构造方法RunDemo(String) 只有一个参数，用来对成员变量userName 赋初值。第二个构造方法RunDemo(String, String) 有两个参数，并有更多的内容，首先调用this(name)，其实际作用就是调用当前类的构造方法RunDemo(String name)；然后对成员变量password 赋值；最后调用check 方法来检查userName 和password，类似于一般程序的口令验证。重载构造方法的执行由对象根据实际参数的个数、类型和顺序确定。

（三）使用键盘输入

1. 程序功能：运行程序后，从键盘输入数字 1、2或者3 ，可显示抽奖得到的奖品；如果输入其它数字或字符则显示“对不起，没有奖品给你!”。

2. 程序源代码如下。

import java.io.*;

      class KY5_3 {

          public static voidmain(String args[]) throws IOException {

            char ch;

           System.out.println("抽奖游戏，祝您好运!");

            System.out.println("按 1、2、3 数字键后回车，可得大奖!");

           System.out.println("按空格键后回车，可退出本游戏.");

            while((ch=(char)System.in.read())!=' ')

            {

              System.in.skip(2);     // 跳过回车键

               switch (ch) {

               case '1':

                System.out.println("恭喜您得大奖，一辆汽车!");

                 break;

               case '2':

                System.out.println("不错呀，您得到一台笔记本电脑!");

                 break;

               case '3':

                 System.out.println("没有白来，您得到一台冰箱!");

                 break;

               default:

                System.out.println("对不起，没有奖品给您!欢迎下次光临。");

             }

          } 

        }

       }

3．编译并运行KY5_3.java

4．运行程序，从键盘输入一下数字或字符，看看程序的输出结果是什么？把这些结果写在实验报告中。

输出结果：

（四）使用多重循环语句

1．请编写程序 KY5_4.java，要求程序能够输出九九乘法表。

2．程序源代码如下。

public class KY5_4

    {

      public static void main(Stringargs[])

      {

         int i, j, n=9;

          System.out.print("      *  |");

          for (i=1; i<=n; i++)  { System.out.print("    "+i);  }   //第一个for循环

         System.out.print("\n----------|");

          for (i=1; i<=n; i++)  { System.out.print("-----");  }     //第二个for循环

          System.out.println();

          for (i=1; i<=n; i++)                               //第三个for循环

          {

              System.out.print("     "+i+"    |");

              for (j=1; j<=i; j++)  { System.out.print("   "+i*j);  }   //第四个for循环

              System.out.println();

         }

      }

 }

3．编译并运行KY5_4.java

4．请将程序的运行结果写在实验报告中，并且说明程序中每一个for循环的作用。

输出结果：

第一个for循环的作用：输出列号： 1 2 3 4 5 6 7 8 9

第二个for循环的作用：输出分隔符：---------------------------------------------

第三个for循环的作用：输出每一行的行号和分隔符

第四个for循环的作用：输出9*9乘法表每一行的结果

四、心得体会：

通过这次实验，理解了类的多态性，掌握了方法的继承、重载和覆盖，掌握了如何从键盘输入数据以及多重循环的使用。类的继承发生在多个类之间，而类的多态只发生在同一个类上。在一个类中，可以定义多个同名的方法，只要确定它们的参数个数和类型不同。这种现象称为类的多态。多态使程序简洁，为程序员带来很大便利。在OOP 中，当程序要实现多个相近的功能时，就给相应的方法起一个共同的名字，用不同的参数代表不同的功能。这样，在使用方法时不论传递什么参数，只要能被程序识别就可以得到确定的结果。类的多态性体现在方法的重载（overload）上，包括成员方法和构造方法的重载。方法的重载是指对同名方法的不同使用方式。构造方法的名称和类同名，没有返回类型。尽管构造方法看起来和一般的成员方法没有差别，但它不是方法，也不是类的成员。因此，构造方法不能直接调用，只能由new 操作符调用。构造方法对于类是十分重要的，对象的初始化任务要靠构造方法来完成。重载构造方法的目的是提供多种初始化对象的能力，使程序员可以根据实际需要选用合适的构造方法来初始化对象。