Java实验8《抽象类和接口》

本是古典 何须时尚 2021-11-23 02:16 427阅读 0赞

一、实验目的

  1. 设计和使用抽象类
  2. 定义接口以及实现接口的类
  3. 理解接口继承和多态

二、实验内容

  1. （P455，13.1）【三角形类】设计一个扩展自抽象类GeometriObject的新的Triangle类。绘制Triangle类和GeometricObject类的UML图并实现Triangle类。编写一个测试程序，提示用户输入三角形的三条边、一种颜色以及一个表明该三角形是否填充的布尔值。程序应该根据用户的输入，使用这些边以及颜色和是否填充的信息，创建一个Triangle对象。程序应该显示面积、周长、颜色以及真或者假来表明是否被填充。

 1.1 UML图
Alt

 1.2 程序代码：
（1）program1源程序

  1. //program1源程序
  2. import java.util.Scanner;
  4. public class program1 { 
  5.      public static void main(String[] args){ 
  6.     Scanner input = new Scanner(System.in);
  7.     boolean continueInput = true;
  9.     while(continueInput){ 
  10.         //输入三角形的三条边
  11.         System.out.print("请输入三角形的三条边长：");
  12.         double side1 = input.nextDouble();
  13.         double side2 = input.nextDouble();
  14.         double side3 = input.nextDouble();
  15.   //判断三条边是否构成三角形，能够成则继续，反之则重新输入
  16.        if((side1+side2>side3) && (side1+side3>side2) && (side2+side3>side1)){ 
  17.         //输入三角形的颜色
  18.         System.out.print("请输入三角形的颜色：");
  19.         String color = input.next();
  20.         //输入三角形是否填充
  21. System.out.print("请输入三角形是否被填充（true为1/false为0）：");
  22.         int fill = input.nextInt();
  24.         GeometricObject triangle = new Triangle(side1, side2, side3);
  25.         triangle.setColor(color);
  26.       boolean filled;
  27.       if(fill==0)
  28.             filled=false;
  29.        else
  30.             filled=true;
  31.         triangle.setFilled(filled);
  32.         System.out.println(triangle.toString());
  33.         continueInput = false;
  34.        }
  35.        else
  36.     System.out.println("输入有误，这三条边不能构成一个三角形。\n");
  37.     }//while结束
  38.      }//main方法结束
  39. }//class结束

（2）Triangle类程序

  1. //Triangle类程序
  2. public class Triangle extends GeometricObject { 
  3.     private double side1;
  4.     private double side2;
  5.     private double side3;
  7.     //创建无参构造方法 
  8.     public Triangle(){ 
  9.          side1 = 1.0;
  10.          side2 = 1.0;
  11.          side3 = 1.0;
  12.     }
  14.     public Triangle(double side1, double side2, double side3){ 
  15.         this.side1 = side1;
  16.         this.side2 = side2;
  17.         this.side3 = side3;
  18.    }
  20.     public double getSide1(){ 
  21.         return side1;
  22.    }
  24.     public double getSide2(){ 
  25.         return side1;
  26.    }
  28.     public double getSide3(){ 
  29.         return side1;
  30.    }
  32.     public void setSide1(double side1){ 
  33.         this.side1=side1;
  34.     }
  36.     public void setSide2(double side2){ 
  37.         this.side2=side2;
  38.     }
  40.     public void setSide3(double side3){ 
  41.         this.side3=side3;
  42.     }
  44.     public double getArea(){ 
  45.         //平均边长s
  46.         double s = ( side1 + side2 + side3 ) / 2.0;
  47.         //计算面积
  48.         return Math.sqrt( s * (s-side1) * (s-side2) * (s-side3) );
  49.     }//getArea结束
  51.     public double getPerimeter(){ 
  52.       return side1+side2+side3;
  53.     }
  55.     @Override
  56.     public String toString(){ 
  57.         return "\narea: " + getArea() + "\tperimeter: " + getPerimeter()
  58.          + "\ncolor: " + super.getColor() + "\tfilled: " + super.isFilled();
  59.    }
  60. }//Triangle类结束

（3）GeometricObject类源程序

  1. //GeometricObject类源程序
  2. public abstract class GeometricObject { 
  3.     private String color = "white";
  4.     private boolean filled;
  5.     private java.util.Date dateCreated;
  7.     //无参构造函数
  8.     protected GeometricObject(){ 
  9.     dateCreated = new java.util.Date();
  10.     }        
  12.     protected GeometricObject(String color, boolean filled){ 
  13.         dateCreated = new java.util.Date();
  14.         this.color = color;
  15.         this.filled = filled;
  16.     }
  18.     public String getColor(){ 
  19.         return color;
  20.     }
  22.     public void setColor(String color){ 
  23.         this.color = color;
  24.     }
  26.     public boolean isFilled(){ 
  27.          return filled;
  28.     }
  30.     public void setFilled(boolean filled){ 
  31.          this.filled = filled;
  32.     }
  34.     public java.util.Date getDateCreated(){ 
  35.          return dateCreated;
  36.     }
  38.     @Override
  39.     public String toString(){ 
  40.           return "created on " + dateCreated + "\ncolor: " + color +
  41.                   " and filled: " + filled;
  42.     }
  44.     public abstract double getArea();
  46.     public abstract double getPerimeter();
  47. }//GeometricObject类结束

  1.3 运行结果与分析：
在这里插入图片描述
    运行正确，符合要求，提示用户输入三角形的三条边、一种颜色以及一个表明该三角形是否填充的布尔值。程序显示面积、周长、颜色以及真或者假来表明是否被填充。

  1.4 心得体会：
    此程序为抽象类的基本运用，注意UML图中抽象类名与抽象方法使用斜体表示，父类中定义抽象方法，子类中实现抽象方法即可，其他操作与一般类一样。

  1. （P456, 13.6）【ComparableCircle类】创建名为ComparableCircle的类，它继承自Circle类，并实现Comparable接口。画出UML图并实现compareTo方法，使其根据面积比较两个圆。编写一个测试程序求出ComparableCircle对象的两个实例中的较大者。

 2.1 UML图
在这里插入图片描述

 2.2 程序代码：
（1）program2源程序：

  1. //program2源程序：
  2. import java.util.Scanner;
  3. public class program2{ 
  4.     public static void main (String[] args){ 
  5.     Scanner input = new Scanner(System.in);
  7.     //输入两个圆的半径
  8.     System.out.print("请输入两个圆的半径：");
  9.     double radius1 = input.nextDouble();
  10.     double radius2 = input.nextDouble();
  12.     //创建两个圆
  13.     ComparableCircle circle1 = new ComparableCircle(radius1);
  14.     ComparableCircle circle2 = new ComparableCircle(radius2);
  15.     int compara = circle1.comparaTo(circle2);
  17.     //比较两个圆的面积大小，输出结果
  18.     if(compara > 0)
  19.         System.out.println("circle1 > circle2");
  20.     else if(compara == 0)
  21.         System.out.println("circle1 = circle2");
  22.     else
  23.         System.out.println("circle1 < circle2");
  24.     }    
  25. }//class结束

（2）ComparableCircle类源程序：

  1. //ComparableCircle类源程序
  2. public class ComparableCircle extends Circle
  3.       implements Comparable<ComparableCircle> { 
  5.      public ComparableCircle(double radius){ 
  6.         super(radius);
  7.      }
  9.      //实现comparaTo方法
  10.      public int comparaTo(ComparableCircle o){ 
  11.          if(getArea() > o.getArea())
  12.               return 1;
  13.          else if(getArea() == o.getArea())
  14.               return 0;
  15.          else
  16.               return -1;
  17.      }
  18. }//calss结束

（3）接口Comparable源程序：

  1. //接口Comparable源程序
  2. public interface Comparable<ComparableCircle>{ 
  3.      public int comparaTo(ComparableCircle o);
  4. }

（4）Circle类源程序：

  1. //Circle类源程序
  2. public class Circle{ 
  3.     public static final double PI = 3.14159;
  4.     private double radius;
  6.     public Circle(){ 
  7.         radius=1.0;
  8.     }
  10.     public Circle(double radius){ 
  11.          this.radius=radius;
  12.     }
  14.     public double getRadius(){ 
  15.         return radius;
  16.     }
  18.     public void setRadius(double radius){ 
  19.         this.radius=radius;
  20.     }
  22.     public double getArea(){ 
  23.         return PI*radius*radius;
  24.     }
  26.     public double getPerimeter(){ 
  27.        return PI*radius*2;
  28.     }
  29. }//class结束

  2.3 运行结果与分析：
Alt
    运行正确，符合题目要求，比较给定半径的两个实例圆，输出较大者。

  2.4 心得体会：
    此程序是接口的初步运用，最主要是几个类之间的调用关系要分清楚，以及接口中只有抽象方法的定义，抽象方法实现在具体类中。

  1. （P456,13.7）【可着色接口Colorable】设计一个名为Colorable的接口，其中有名为howToColor()的void方法。可着色对象的每个类必须实现Colorable接口。设计一个扩展GeometricObject类并实现Colorable接口的名为Square的类。实现howToColor方法，显示消息“给所有的四条边着色”。
    画出包含Colorable、Square和GeometricObject的UML图。编写一个测试程序，创建有五个GeometricObject对象的数组。对于数组中的每个对象而言，如果对象是可着色的，那就调用howToColor方法。

 3.1 UML图
在这里插入图片描述

 3.2 程序代码：
（1）program3的源程序：

  1. //program3的源程序
  2. public class program3{ 
  3.     public static void main(String[] args){ 
  4.         //创建有五个GeometricObject对象的数组
  5.         GeometricObject[] geometricObject = { new Circle(), 
  6. new Square(),  new Rectangle(),  new Square(),  new Triangle()};
  7.      //判断每个对象是否可着色，可以着色则调用howToColor方法
  8.         for(int i=0; i<geometricObject.length; i++){ 
  9.             if(geometricObject[i] instanceof Colorable){ 
  10.                 System.out.print("geometricObject " + (i+1) + " : ");
  11.                ((Colorable)geometricObject[i]).howToColor();
  12.             }
  13.         }
  14.     }//main结束
  15. }//class结束
  17. class Circle extends GeometricObject{ 
  18.     private double radius;
  20.     //无参构造方法
  21.     public Circle(){ 
  23.     }
  24. }
  26. class Triangle extends GeometricObject{ 
  27.      private double side1, side2, side3;
  29.      //无参构造方法
  30.      public Triangle(){ 
  32.      }
  33. }
  35. class Rectangle extends GeometricObject{ 
  36.      private double width, height;
  38.      //无参构造方法
  39.      public Rectangle(){ 
  41.      }
  42. }

（2）Square类的源程序：

  1. //Square类的源程序
  2. public class Square extends GeometricObject 
  3.       implements Colorable{ 
  4.       private double sideLength;
  5.       //无参构造方法
  6.       public Square(){ 
  7.             sideLength=1.0;
  8.       }
  9.       //含参构造方法
  10.       public Square(double sideLength){ 
  11.            this.sideLength = sideLength;
  12.       }
  14.       public void howToColor(){ 
  15.           System.out.println("给所有的四条边长着色");
  16.       }
  18.       public double getSideLength(){ 
  19.           return sideLength;
  20.       }
  22.       public void setSideLength(double sideLength){ 
  23.           this.sideLength = sideLength;
  24.       }
  25. }//class结束

（3）Colorable接口的源程序：

  1. //Colorable接口的源程序
  2. public interface Colorable{ 
  3.      public void howToColor();
  4. }

（4）GeometricObject类的源程序：

  1. //GeometricObject类的源程序
  2. public class GeometricObject { 
  3.     private String color = "white";
  4.     private boolean filled;
  5.     private java.util.Date dateCreated;
  7.     //无参构造函数
  8.     protected GeometricObject(){ 
  9.     dateCreated = new java.util.Date();
  10.     }        
  12.     protected GeometricObject(String color, boolean filled){ 
  13.         dateCreated = new java.util.Date();
  14.         this.color = color;
  15.         this.filled = filled;
  16.     }
  18.     public String getColor(){ 
  19.         return color;
  20.     }
  22.     public void setColor(String color){ 
  23.         this.color = color;
  24.     }
  26.     public boolean isFilled(){ 
  27.          return filled;
  28.     }
  30.     public void setFilled(boolean filled){ 
  31.          this.filled = filled;
  32.     }
  34.     public java.util.Date getDateCreated(){ 
  35.          return dateCreated;
  36.     }
  37.     @Override
  38.     public String toString(){ 
  39.           return "created on " + dateCreated + "\ncolor: " + color +
  40.                   " and filled: " + filled;
  41.     }
  42. }//GeometricObject类结束

  3.3 运行结果与分析：
在这里插入图片描述
    运行正确，符合要求，对于数组中的每个对象而言，如果对象是可着色的，那就调用howToColor方法。数组geometricObject中的五个对象分别是Circle, Square, Rectangle,Square, Triangle，其中只有对象Square可着色，所以程序运行结果显示数组中的第2个对象和第4个对象可着色，调用howToColor方法，显示消息。

  3.4 心得体会：
    此程序是接口的进一步使用，接口内定义howToColor方法，Square内实现howToColor方法，主程序判断对象是否可着色再确定是否调用。其他即为类的简单使用。

  1. 【附加题，可选做】【找出最大的对象】编写一个方法，返回对象数组中最大的对象。方法签名如下：
    public static Object max(Comparable[] a)
    所有对象都是Comparable接口的实例。对象在数组中的顺序是由compareTo方法决定的。
    编写测试程序，创建一个由10个字符串构成的数组，一个由10个整数构成的数组和一个由10个日期构成的数组，找出数组中最大的字符串、整数和日期。

4.1 程序代码：

  1. import java.util.Date;  
  2. import java.text.SimpleDateFormat;
  3. import java.lang.Comparable;
  5. public class program4{ 
  6.      public static void main(String[] args){ 
  7.         String[] a = { "apple","pear","banana","orange","anna",
  8.                       "spring","summer","autumn", "winter","date"};
  9.         Integer[] b = { 1, 8, 5, 4, 2, 3, 9, 7, 6, 2};
  10.  //Date中年月日表示为 年：理想年-1900 月：理想月-1 日：理想日
  11.         Date date1 = new Date(2018-1900, 6-1, 16);
  12.         Date date2 = new Date(2019-1900, 5-1, 26);
  13.         Date date3 = new Date(2008-1900, 8-1, 8);
  14.         Date date4 = new Date(2009-1900, 7-1, 9);
  15.         Date date5 = new Date(2001-1900, 4-1, 3);
  16.         Date date6 = new Date(2015-1900, 9-1, 17);
  17.         Date date7 = new Date(2020-1900, 12-1, 21);
  18.         Date date8 = new Date(2013-1900, 11-1, 11);
  19.         Date date9 = new Date(2002-1900, 2-1, 2);
  20.         Date date10 = new Date(2014-1900, 1-1, 28);
  21.         Date[] c = { date1, date2, date3, date4, date5,
  22.                   date6, date7, date8, date9, date10}; 
  23.         //规范日期输出形式为：年-月-日
  24.         SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd");
  26.         //输出三个数组
  27.         System.out.print("String: ");
  28.         for(String e: a)
  29.             System.out.print(e + " ");
  30.         System.out.print("\nInteger: ");
  31.         for(Integer e: b)
  32.             System.out.print(e + " ");
  33.         System.out.print("\nDate: ");
  34.         //每行5个日期
  35.         for(int i=0; i<c.length; i++){ 
  36.             if( (i+1) % 5 == 0){ 
  37.                System.out.println( ft.format(c[i]) + " ");
  38.                System.out.print(" ");
  39.             }               
  40.             else
  41.                System.out.print( ft.format(c[i]) + " ");
  42.         }
  43.         //调用max方法，输出每个数组的最大值
  44.         System.out.println("\nMax of String : " + max(a));
  45.         System.out.println("Max of Integer : " + max(b));
  46.         System.out.println("Max of Date : " + ft.format(max(c)) );
  47.      }//main方法结束
  49.      public static Object max(Comparable[] a){ 
  50.           Comparable max = null;
  51.     //先判断每个数组类型，再用comparaTo依次比较选择出最大值
  52.           if(a[0] instanceof String){ 
  53.               max = (String)a[0];
  54.               for(int i=1; i<a.length; i++){ 
  55.                  if(max.compareTo((String) a[i]) < 0)
  56.                      max = (String)a[i];
  57.               }
  58.           }
  59.           else if(a[0] instanceof Integer){ 
  60.               max = (Integer)a[0];
  61.               for(int i=1; i<a.length; i++){ 
  62.                  if(max.compareTo((Integer) a[i]) < 0)
  63.                      max = (Integer)a[i];
  64.               }
  65.           }
  66.           else if(a[0] instanceof Date){ 
  67.               max = (Date)a[0];
  68.               for(int i=1; i<a.length; i++){ 
  69.                  if(max.compareTo((Date) a[i]) < 0)
  70.                      max = (Date)a[i];
  71.               }
  72.          }
  73.          return max;
  74.      }//max方法结束
  76. }//class结束

4.2 运行结果：
在这里插入图片描述
  程序运行正确，符合输出要求，编译过程有点小问题（解释见心得体会），创建三个不同类型（字符串、整数和日期）的数组，调用max方法求最大值。

4.3 心得体会：
  此程序为主要为Comparable接口的应用，创建三个数组，调用max方法，用instanceof确定数组类型，再用for循环与compareTo方法比较确定最大值，max中需注意数组中元素使用时的及时转换。
编译过程中的问题1：使用已过时API，部分截图见下，Date数组中元素的创建时使用的自定义日期方法已过时。所以为了满足题目要求而使用，不影响程序运行。
在这里插入图片描述
编译过程中的问题2：使用未经检查的操作，部分截图见下，max方法中判断数组类型时只是使用第一个元素进行判定，其他元素未判定。但是，程序在创建数组已确定数组中所有元素均为同一类型，所以此处忽略后续元素的判定，不影响程序运行。
在这里插入图片描述

发表评论

表情：
评论列表 （有 0 条评论，427人围观）

还没有评论，来说两句吧...

相关阅读

    相关 java8之后的接口和抽象类

    java8 1.接口可以写默认方法（default）和静态方法，好处是当需要对接口进行修改时，在子类中不需要实现而且可以重写默认方法；如果添加的是静态方法，子类可以直接使用

    桃扇骨桃扇骨/ 0 赞/ 172 阅读

    相关 Java抽象类和接口

    抽象类是一种功能不全的类，接口是一个抽象方法声明和静态不能被修改的数据的集合，两者都不能被实例化。从某种意义上说，接口是一种特殊形式的抽象类，在Java语言中，抽象类表示一种继

    电玩女神电玩女神/ 0 赞/ 545 阅读

    相关 java接口和抽象类

    1、抽象类最大的特征就是在普通类的基础上追加了抽象方法，而事实上抽象类定义里面也存在有若干的问题 。将抽象方法和普通方法写在一起有些乱 。抽象类本身会存在单继承的局限

    短命女短命女/ 0 赞/ 391 阅读

    相关 JAVA抽象类和接口

    抽象类： 定义一个类的时候，常常需要定义一些方法来描述该类的行为特征，但有时候这些方法的实现方式无法确定。 针对这种情况，Java允许在定义方法的时候可以不写方法体，不

    系统管理员系统管理员/ 0 赞/ 396 阅读

    相关 Java抽象类和接口

    父类定义了子类中的共同行为，接口定义不同类的共同行为。 抽象类 抽象类不可 new 一个实例，可以包含抽象方法，没有实现，这些方法在子类中实现。 使用 abstrac

    旧城等待，旧城等待，/ 0 赞/ 369 阅读