精华内容
下载资源
问答
  • Java实验8《抽象类和接口

    千次阅读 2019-07-25 15:57:05
    设计使用抽象类 定义接口以及实现接口的类 理解接口继承多态 二、实验内容 (P455,13.1)【三角形类】设计一个扩展自抽象类GeometriObject的新的Triangle类。绘制Triangle类GeometricObject类的UML图并实现...

    一、实验目的

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

    二、实验内容

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

     1.1 UML图
    Alt

     1.2 程序代码:
    (1)program1源程序

    //program1源程序
    import java.util.Scanner;
    
    public class program1 {
         public static void main(String[] args){
    	Scanner input = new Scanner(System.in);
    	boolean continueInput = true;
    		
    	while(continueInput){
    	    //输入三角形的三条边
    	    System.out.print("请输入三角形的三条边长:");
    	    double side1 = input.nextDouble();
    	    double side2 = input.nextDouble();
    	    double side3 = input.nextDouble();
      //判断三条边是否构成三角形,能够成则继续,反之则重新输入
    	   if((side1+side2>side3) && (side1+side3>side2) && (side2+side3>side1)){
    		//输入三角形的颜色
    		System.out.print("请输入三角形的颜色:");
    		String color = input.next();
    		//输入三角形是否填充
    System.out.print("请输入三角形是否被填充(true为1/false为0):");
    		int fill = input.nextInt();
    				
    		GeometricObject triangle = new Triangle(side1, side2, side3);
    		triangle.setColor(color);
          boolean filled;
          if(fill==0)
                filled=false;
           else
                filled=true;
    		triangle.setFilled(filled);
    		System.out.println(triangle.toString());
    		continueInput = false;
    	   }
    	   else
    	System.out.println("输入有误,这三条边不能构成一个三角形。\n");
    	}//while结束
         }//main方法结束
    }//class结束
    

    (2)Triangle类程序

    //Triangle类程序
    public class Triangle extends GeometricObject {
    	private double side1;
    	private double side2;
    	private double side3;
    	
        //创建无参构造方法        
        public Triangle(){
             side1 = 1.0;
             side2 = 1.0;
             side3 = 1.0;
        }
        
        public Triangle(double side1, double side2, double side3){
            this.side1 = side1;
            this.side2 = side2;
            this.side3 = side3;
       }
        
        public double getSide1(){
            return side1;
       }
        
        public double getSide2(){
            return side1;
       }
       
        public double getSide3(){
            return side1;
       }
       
        public void setSide1(double side1){
        	this.side1=side1;
        }
        
        public void setSide2(double side2){
        	this.side2=side2;
        }
        
        public void setSide3(double side3){
        	this.side3=side3;
        }
        
        public double getArea(){
            //平均边长s
            double s = ( side1 + side2 + side3 ) / 2.0;
            //计算面积
            return Math.sqrt( s * (s-side1) * (s-side2) * (s-side3) );
        }//getArea结束
     
        public double getPerimeter(){
          return side1+side2+side3;
        }
        
        @Override
        public String toString(){
            return "\narea: " + getArea() + "\tperimeter: " + getPerimeter()
             + "\ncolor: " + super.getColor() + "\tfilled: " + super.isFilled();
       }
    }//Triangle类结束
    

    (3)GeometricObject类源程序

    //GeometricObject类源程序
    public abstract class GeometricObject {
    	private String color = "white";
    	private boolean filled;
    	private java.util.Date dateCreated;
    	  
    	//无参构造函数
    	protected GeometricObject(){
    	dateCreated = new java.util.Date();
    	}        
    	          
    	protected GeometricObject(String color, boolean filled){
    		dateCreated = new java.util.Date();
    	    this.color = color;
    	    this.filled = filled;
    	}
    	          
    	public String getColor(){
    	    return color;
    	}
    
    	public void setColor(String color){
    	    this.color = color;
        }
    	           
    	public boolean isFilled(){
    	     return filled;
        }
    	    
    	public void setFilled(boolean filled){
    	     this.filled = filled;
    	}
    
    	public java.util.Date getDateCreated(){
    	     return dateCreated;
    	}
    
    	@Override
    	public String toString(){
    	      return "created on " + dateCreated + "\ncolor: " + color +
    	              " and filled: " + filled;
    	}
    	
    	public abstract double getArea();
    
    	public abstract double getPerimeter();
    }//GeometricObject类结束
    

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

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


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

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

     2.2 程序代码:
    (1)program2源程序:

    //program2源程序:
    import java.util.Scanner;
    public class program2{
        public static void main (String[] args){
        Scanner input = new Scanner(System.in);
        
        //输入两个圆的半径
        System.out.print("请输入两个圆的半径:");
        double radius1 = input.nextDouble();
        double radius2 = input.nextDouble();
    
        //创建两个圆
        ComparableCircle circle1 = new ComparableCircle(radius1);
        ComparableCircle circle2 = new ComparableCircle(radius2);
        int compara = circle1.comparaTo(circle2);
    
        //比较两个圆的面积大小,输出结果
        if(compara > 0)
            System.out.println("circle1 > circle2");
        else if(compara == 0)
            System.out.println("circle1 = circle2");
        else
            System.out.println("circle1 < circle2");
        }    
    }//class结束
    

    (2)ComparableCircle类源程序:

    //ComparableCircle类源程序
    public class ComparableCircle extends Circle
          implements Comparable<ComparableCircle> {
    
         public ComparableCircle(double radius){
            super(radius);
         }
    
         //实现comparaTo方法
         public int comparaTo(ComparableCircle o){
             if(getArea() > o.getArea())
                  return 1;
             else if(getArea() == o.getArea())
                  return 0;
             else
                  return -1;
         }
    }//calss结束
    

    (3)接口Comparable源程序:

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

    (4)Circle类源程序:

    //Circle类源程序
    public class Circle{
        public static final double PI = 3.14159;
        private double radius;
    
        public Circle(){
            radius=1.0;
        }
    
        public Circle(double radius){
             this.radius=radius;
        }
    
        public double getRadius(){
            return radius;
        }
    
        public void setRadius(double radius){
            this.radius=radius;
        }
    
        public double getArea(){
            return PI*radius*radius;
        }
    
        public double getPerimeter(){
           return PI*radius*2;
        }
    }//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的源程序:

    //program3的源程序
    public class program3{
        public static void main(String[] args){
            //创建有五个GeometricObject对象的数组
            GeometricObject[] geometricObject = {new Circle(), 
    new Square(),  new Rectangle(),  new Square(),  new Triangle()};
         //判断每个对象是否可着色,可以着色则调用howToColor方法
            for(int i=0; i<geometricObject.length; i++){
                if(geometricObject[i] instanceof Colorable){
                    System.out.print("geometricObject " + (i+1) + " : ");
                   ((Colorable)geometricObject[i]).howToColor();
                }
            }
        }//main结束
    }//class结束
    
    class Circle extends GeometricObject{
        private double radius;
     
        //无参构造方法
        public Circle(){
    
        }
    }
    
    class Triangle extends GeometricObject{
         private double side1, side2, side3;
    
         //无参构造方法
         public Triangle(){
             
         }
    }
    
    class Rectangle extends GeometricObject{
         private double width, height;
    
         //无参构造方法
         public Rectangle(){
             
         }
    }
    

    (2)Square类的源程序:

    //Square类的源程序
    public class Square extends GeometricObject 
          implements Colorable{
          private double sideLength;
          //无参构造方法
          public Square(){
                sideLength=1.0;
          }
          //含参构造方法
          public Square(double sideLength){
               this.sideLength = sideLength;
          }
    
          public void howToColor(){
              System.out.println("给所有的四条边长着色");
          }
    
          public double getSideLength(){
              return sideLength;
          }
    
          public void setSideLength(double sideLength){
              this.sideLength = sideLength;
          }
    }//class结束
    

    (3)Colorable接口的源程序:

    //Colorable接口的源程序
    public interface Colorable{
         public void howToColor();
    }
    

    (4)GeometricObject类的源程序:

    //GeometricObject类的源程序
    public class GeometricObject {
    	private String color = "white";
    	private boolean filled;
    	private java.util.Date dateCreated;
    	  
    	//无参构造函数
    	protected GeometricObject(){
    	dateCreated = new java.util.Date();
    	}        
    	          
    	protected GeometricObject(String color, boolean filled){
    		dateCreated = new java.util.Date();
    	    this.color = color;
    	    this.filled = filled;
    	}
    	          
    	public String getColor(){
    	    return color;
    	}
    
    	public void setColor(String color){
    	    this.color = color;
        }
    	           
    	public boolean isFilled(){
    	     return filled;
        }
    	    
    	public void setFilled(boolean filled){
    	     this.filled = filled;
    	}
    
    	public java.util.Date getDateCreated(){
    	     return dateCreated;
    	}
    	@Override
    	public String toString(){
    	      return "created on " + dateCreated + "\ncolor: " + color +
    	              " and filled: " + filled;
    	}
    }//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 程序代码:

    import java.util.Date;  
    import java.text.SimpleDateFormat;
    import java.lang.Comparable;
    
    public class program4{
         public static void main(String[] args){
            String[] a = {"apple","pear","banana","orange","anna",
                          "spring","summer","autumn", "winter","date"};
            Integer[] b = {1, 8, 5, 4, 2, 3, 9, 7, 6, 2};
     //Date中年月日表示为 年:理想年-1900 月:理想月-1 日:理想日
            Date date1 = new Date(2018-1900, 6-1, 16);
            Date date2 = new Date(2019-1900, 5-1, 26);
            Date date3 = new Date(2008-1900, 8-1, 8);
            Date date4 = new Date(2009-1900, 7-1, 9);
            Date date5 = new Date(2001-1900, 4-1, 3);
            Date date6 = new Date(2015-1900, 9-1, 17);
            Date date7 = new Date(2020-1900, 12-1, 21);
            Date date8 = new Date(2013-1900, 11-1, 11);
            Date date9 = new Date(2002-1900, 2-1, 2);
            Date date10 = new Date(2014-1900, 1-1, 28);
            Date[] c = {date1, date2, date3, date4, date5,
                      date6, date7, date8, date9, date10}; 
            //规范日期输出形式为:年-月-日
            SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd");
    
            //输出三个数组
            System.out.print("String: ");
            for(String e: a)
                System.out.print(e + " ");
            System.out.print("\nInteger: ");
            for(Integer e: b)
                System.out.print(e + " ");
            System.out.print("\nDate: ");
            //每行5个日期
            for(int i=0; i<c.length; i++){
                if( (i+1) % 5 == 0){
                   System.out.println( ft.format(c[i]) + " ");
                   System.out.print("      ");
                }               
                else
                   System.out.print( ft.format(c[i]) + " ");
            }
            //调用max方法,输出每个数组的最大值
            System.out.println("\nMax of String  : " + max(a));
            System.out.println("Max of Integer : " + max(b));
            System.out.println("Max of Date    : " + ft.format(max(c)) );
         }//main方法结束
    
         public static Object max(Comparable[] a){
              Comparable max = null;
        //先判断每个数组类型,再用comparaTo依次比较选择出最大值
              if(a[0] instanceof String){
                  max = (String)a[0];
                  for(int i=1; i<a.length; i++){
                     if(max.compareTo((String) a[i]) < 0)
                         max = (String)a[i];
                  }
              }
              else if(a[0] instanceof Integer){
                  max = (Integer)a[0];
                  for(int i=1; i<a.length; i++){
                     if(max.compareTo((Integer) a[i]) < 0)
                         max = (Integer)a[i];
                  }
              }
              else if(a[0] instanceof Date){
                  max = (Date)a[0];
                  for(int i=1; i<a.length; i++){
                     if(max.compareTo((Date) a[i]) < 0)
                         max = (Date)a[i];
                  }
             }
             return max;
         }//max方法结束
    
    }//class结束
    

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

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


    展开全文
  • Java抽象类接口实验报告
  • Java基础 实验抽象类和接口

    千次阅读 2019-01-12 19:43:16
     1、定义一个抽象类Shape,它包含一个抽象方法getArea(),从Shape类派生出RectangleCircle类,这两个类都用getArea()方法计算对象的面积。编写应用程序使用RectangleCircle类。 实验要求:定义Rectangle...

    一、实验内容

        1、定义一个抽象类Shape,它包含一个抽象方法getArea(),从Shape类派生出Rectangle和Circle类,这两个类都用getArea()方法计算对象的面积。编写应用程序使用Rectangle和Circle类。

    实验要求:定义Rectangle和Circle类的构造方法,初始化成员变量。

        2、学校中有老师和学生两类人,而在职研究生既是老师又是学生。

        1)设计两个信息管理接口StudentInterface和TeacherInterface,其中StudentInterface接口包括setFee()方法和getFee()方法,分别用于设置和获取学生的学费,TeacherInterface接口包括setPay()和getPay()方法,分别用于设置和获取老师的工资。

        2)定义一个研究生类Graduate,实现StudentInterface接口和TeacherInterface接口,它定义的成员变量有name(姓名),sex(性别),age(年龄),fee(每学期学费) pay(月工资)。

        3)创建一个姓名为“zhangsan”的研究生,统计他的年收入和学费,如果收入减去学费不足2000元,则输出“You  need a loan!”(需要贷款)的信息,否则输出“You income is enough!”信息。

    实验要求:在Graduate中实现各个接口声明的抽象方法。

    二、实验记录

        1、Shape.java(抽象类)

    package exceptionsix;
    
    public abstract class Shape {
        double x,y;
        double r;
        Shape () {
            x = 0;
            y = 0;
            r = 0;
        }
        Shape (double a) {
            r = a;
        }
        Shape (double a, double b) {
        x = a;
        y =b;
        }
        abstract double getArea();
    }

    2、Rectangle.java

    package exceptionsix;
    
    public class Rectangle extends Shape {
        Rectangle () {
            super();
        }
        Rectangle (double a, double b) {
            super(a, b);
        }
        public double getArea () {
            return super.x * super.y;
        }
    }

    3、Circle.java

    package exceptionsix;
    
    public class Circle extends Shape {
        Circle () {
            super ();
        }
        Circle (double r) {
            super(r);
        }
        public double getArea () {
            return super.r * 2 * 3.1415;
        }
    }

    4、StudentInterface.java(接口类)

    package questionTwo;
    public interface StudentInterface {
        double setFee();//设置学费
        double getFee();//获取学费
    }

    5、TeacherInterface.java(接口类)

    package questionTwo;
    public interface TeacherInterface {
        double setPay();//设置工资
        double getPay();//获取工资
    }

    6、Graduate.java

    package questionTwo;
    public class Graduate implements StudentInterface, TeacherInterface{
        private String name;
        private String sex;
        private int age;
        private double fee;
        private double pay;
        public void setName(String a) {
            name = a;
        }
        public void setSex(String a) {
            sex = a;
        }
        public void setAge(int a) {
            age = a;
        }
        public void setFeePay(double a, double b) {
            fee = a;
            pay = b;
        }
        public double setFee(){
            return 0;
        }
        public double getFee(){//返回每学年的费用
            return fee * 2;
        }
        public double setPay(){
            return 0;
        }
        public double getPay(){//返回年收入
            return pay * 12;
        }
    }

    7、ExceptionSix.java(主类) 

    package exceptionsix;
    import questionTwo.*;
    public class ExceptionSix {
        public static void main(String[] args) {
            System.out.println("问题一:*************************************************");
            Rectangle rec = new Rectangle (5.2, 13.14);
            System.out.println("矩形的面积为:"+rec.getArea());
            Circle cir = new Circle (5.2);
            System.out.println("圆的面积为:"+cir.getArea());
            System.out.println("问题二:*************************************************");
            Graduate graduate = new Graduate();
            graduate.setName("zhangSan");//设置姓名
            graduate.setFeePay(3250, 500);//设置每学期的费用,月工资
            System.out.println("学费为:"+graduate.getFee());
            System.out.println("年收入为:"+graduate.getPay()); 
            if(graduate.getPay() - graduate.getFee() > 2000) {
                System.out.println("You income is enough!");
            } else {
                System.out.println("You need a loan!");
            }
        }
    }

    三、实验结果

    展开全文
  • 1.设计使用抽象类 2.定义接口以及实现接口的类 3.理解接口继承多态 二、实验内容 1.(P455,13.1)【三角形类】设计一个扩展自抽象类GeometriObject的新的Triangle类。绘制Triangle类GeometricObject类的UML图...

    一、实验目的

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

    二、实验内容

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

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

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

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

    三、实验要求:

    要求每个学生独立完成实验任务。

    四、实验报告
    1.实验结果与分析
    (1)三角形类

    A. UML类图
    在这里插入图片描述
    B. 实验运行
    首先根据提示输入三个边的边长
    在这里插入图片描述
    然后接着根据提示输入字符串类型的颜色信息和布尔类型的填充信息
    在这里插入图片描述最后回车,输出信息在这里插入图片描述
    C.实验过程与结果分析
    首先定义GeometricObject类并定义为抽象类,并定义抽象方法getArea方法和getPerimeter方法;

    public abstract double getArea();
    public abstract double getPerimeter();	
    

    然后定义Triangle类并继承自GeometricObject类,定义三个私有边长数据域。

    private double s1,s2,s3;
    

    定义构造方法。

    	this.s1 = s1;
    	this.s2 = s2;
    	this.s3 = s2;
    	setColor(color);
    	setFilled(filled);
    	Date dateCreated = new Date();
    	setDateCreated(dateCreated);
    

    重写抽象getArea方法和getPerimeter方法。

    public double getArea() {
    		double p = (s1+s2+s3) / 2;
    		return Math.sqrt(p*(p-s1)*(p-s2)*(p-s3));
    	}
    	public double getPerimeter(){
    		return s1 + s2 + s3;
    }
    

    重写已有toString方法。

    public String toString(){
    	return super.toString() + " and area: " + getArea() + " and perimeter: " + getPerimeter();
    }
    

    然后在主方法内测试程序并调用构造方法构造三角形,然后返回测试信息。

    created on Sun Jun 16 19:23:53 CST 2019
    color: white and filled: false and area: 1054.8037435940394 and perimeter: 149.0

    (2)ComparableCircle类
    A. UML类图
    在这里插入图片描述
    B.实验运行
    首先根据提示输入两个圆半径
    在这里插入图片描述
    回车返回哪个圆面积较大,并输出面积大小
    在这里插入图片描述
    C.实验过程与结果分析
    首先定义ComparableCircle类,继承自Circle类,实现Comparable接口

    public class ComparableCircle extends Circle implements Comparable<ComparableCircle> 
    

    然后重写Comparable内的抽象方法,根据大小关系返回大于0,等于0,小于0的值

    public int compareTo(ComparableCircle d){
    		if(this.getArea() < d.getArea())return -1;
    		else if(this.getArea() == d.getArea())return 0;
    		else return 1;
    }
    

    再在主方法内测试程序,创建两个ComparableCircle类型的实例,输入两个半径值并用相关set方法定义实例,再根据调用的compareTo方法输出不同的值。

    if(c1.compareTo(c2) < 0)System.out.println("两圆中的较大者为第二个,面积为" + c2.getArea());
    else if(c1.compareTo(c2) == 0)System.out.println("两圆等大,面积为" + c2.getArea());
    else System.out.println("两圆中的较大者为第一个,面积为" + c1.getArea());
    
    两圆中的较大者为第二个,面积为201.06192982974676
    

    (3)可着色接口Colorable
    A. UML类图
    在这里插入图片描述
    B. 实验运行
    直接回车运行产生结果
    在这里插入图片描述
    C. 实验过程与结果分析
    首先创建Colorable接口并定义抽象方法howToColor

    public interface Colorable {
    		public abstract void howToColor();
    }
    

    然后定义Square类,继承自GeometricObject类,实现Colorable接口

    public class Square extends GeometricObject implements Colorable
    

    再定义私有的是否可以涂颜色的布尔类型数据域和边长的double数据域和其set和get方法

    private boolean canbecolored;
    private double side;
    

    重写GeometricObject类的抽象方法

    	@Override
    	public double getArea() {
    		return side * side;
    	}
    	@Override
    	public double getPerimeter() {
    		return 4 * side;
    }
    

    然后在主方法测试程序,设置一个GeometricObject类型,指向Square类型的一维数组,长度为5;然后循环对数组内的元素创建空间(注意在这里我们要将GeometricObject类型的对象强制转型到Square),然后随机设置是否可以涂色(使用Random类对象的nextBoolean方法)

    GeometricObject[] geometricObjects = new Square[5];
    	for(int i = 0; i < 5;i++){
    	geometricObjects[i] = new Square();
    	((Square)geometricObjects[i]).setCanbecolored(random.nextBoolean());
    }
    

    再循环输出五个实例是否被涂色

    for(int i = 0; i < 5;i++){
    		System.out.println("第" + (i+1) + "个对象");
    		if(((Square)geometricObjects[i]).getCanbecolor()){
    			((Square)geometricObjects[i]).howToColor();
    		}
    		else System.out.println("不可着色");
    }
    

    第1个对象
    不可着色
    第2个对象
    给所有的四条边着色
    第3个对象
    不可着色
    第4个对象
    不可着色
    第5个对象
    给所有的四条边着色

    (4)附加题:找出最大的对象
    A.UML类图
    在这里插入图片描述
    B.实验运行
    首先根据提示输入相关信息,其中日期以YYYY-MM-DD格式输入
    在这里插入图片描述
    回车,返回三种类型的最大值
    在这里插入图片描述
    C.实验过程与结果分析
    首先根据题目要求定义max方法,其中Comparable是接口类,可以是这三类类型的实例数组,然后用instanceof语句判断是哪个类型。

    if(a[0] instanceof String){return max;}
    	if(a[0] instanceof Date){return max;}
    if(a[0] instanceof Integer){return max;}
    return null;
    

    在每个类型内循环遍历使用compareTo方法求最大值(以Date类为例)

    Date max = (Date)a[0];
    	for(int i = 1;i < a.length;i++){
    		if(a[i].compareTo(max) > 0)max = (Date)a[i];
    	}
    return max;
    

    在主方法内定义三个类型的五个长度的数组

    Integer[] num = new Integer[10];
    String[] strings = new String[10];
    Date[] dates = new Date[10];
    

    然后输入内容,其中使用util库内的Date类,然后使用SimpleDateFormat类的时间类型定义(yyyy-mm-dd),然后用其内的方法parse(input.next())输入到Date类型实例中

    SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
    for(int i = 0; i < 10;i++){
    		dates[i] = new Date();
    		dates[i] = simpleDateFormat.parse(input.next());
    }
    

    最后调用max方法,输出结果即可

    int max1 = (int)max(num);
    	String max2 = (String)max(strings);
    	Date max3 = (Date)max(dates);
    	System.out.println("最大整数为: " + max1);
    	System.out.println("最大字符串为: " + max2);
    System.out.println("最大日期为: " + max3);
    

    3.心得体会

    本次实验主要考查对抽象类与接口的方法的运用,同时在建立类与实例的连接上回顾了之前学过的继承与多态相关知识。
    本次实验的难度比较适中,在学过的基础上其实更是针对性的强化,但在附加题的多态,接口和继承的综合应用时有难度的提升,首先遇到的就是Comparable接口是所有类型的父类的一个思想的运用就让我想了很长时间,还有Date类型参量传入的时候,刚开始想的是使用int类型传入,但是测试之后发现没办法转换,就将Date类从sql库转到了util库,再上网查到了SimpleDateFormat定义的方法,最后顺利解决这种问题。
    本次是最后一次实验,在这八次实验中,我认为题目都是很有针对性且很有练习性的,这八次实验的应用,确实提高了我的有关Java的代码能力,同时对理论知识的掌握也在实践的过程中不断深化,实验课是十分有效果的。

    4.附源代码

    1)experiment1	
    GeometricObject类
    import java.util.Date;
    public abstract class GeometricObject {
    	private String color = "white";
    	private boolean filled;
    	private Date dateCreated;
    	
    	protected GeometricObject(){
    		dateCreated = new Date();
    	}
    	protected GeometricObject(String color,boolean filled){
    		dateCreated = new Date();
    		this.color = color;
    		this.filled = filled;
    	}
    	
    	public String getColor(){
    		return color;
    	}
    	public void setColor(String color) {
    		this.color = color;
    	}
    	public boolean isFilled() {
    		return filled;
    	}
    	public void setFilled(boolean filled) {
    		this.filled = filled;
    	}
    	public void setDateCreated(Date dateCreated) {
    		this.dateCreated = dateCreated;
    	}
    	public Date getDateCreated() {
    		return dateCreated;
    	}
    	@Override
    	public String toString() {
    		return "created on " + dateCreated + " \ncolor: " + color
    				+ " and filled: " + filled;
    	}
    	public abstract double getArea();
    	public abstract double getPerimeter();	
    }
    Triangle类
    import java.util.Date;
    import java.util.Scanner;
    public class Triangle extends GeometricObject{
    	private double s1,s2,s3;
    	
    	public Triangle(double s1,double s2,double s3,String color,boolean filled){
    		this.s1 = s1;
    		this.s2 = s2;
    		this.s3 = s2;
    		setColor(color);
    		setFilled(filled);
    		Date dateCreated = new Date();
    		setDateCreated(dateCreated);
    	}
    	public double getArea() {
    		double p = (s1+s2+s3) / 2;
    		return Math.sqrt(p*(p-s1)*(p-s2)*(p-s3));
    	}
    	public double getPerimeter(){
    		return s1 + s2 + s3;
    	}
    	public String toString(){
    		return super.toString() + " and area: " + getArea() + " and perimeter: " + getPerimeter();
    	}
    	public static void main(String[] args) {
    		double s1,s2,s3;
    		String color;
    		boolean filled;
    		Scanner input = new Scanner(System.in);
    		System.out.println("请输入三条边的值与颜色填充信息: ");
    		System.out.print("第一条边长");
    		s1 = input.nextDouble();
    		System.out.print("第二条边长");
    		s2 = input.nextDouble();
    		System.out.print("第三条边长");
    		s3 = input.nextDouble();
    		System.out.print("颜色信息");
    		color = input.next();
    		System.out.print("是否被填充");
    		filled = input.nextBoolean();
    		Triangle triangle = new Triangle(s1, s2, s3, color, filled);
    		System.out.println(triangle.toString());
    
    	}
    }
    
    2)experiment2
    Circle类
    public class Circle {
    	private double radius = 1;
    	public Circle() {}
    	public Circle(double newRadius){
    		radius = newRadius;
    	}
    	public double getArea(){
    		return radius * radius * Math.PI;
    	}
    	public double getPerimeter(){
    		return 2 * radius * Math.PI;
    	}
    	public void setRadius(double radius) {
    		this.radius = radius;
    	}
    	public double getRadius() {
    		return radius;
    	}
    }
    ComparableCircle类
    import java.util.Scanner;
    public class ComparableCircle extends Circle implements Comparable<ComparableCircle> {
    		public int compareTo(ComparableCircle d){
    			if(this.getArea() < d.getArea())return -1;
    			else if(this.getArea() == d.getArea())return 0;
    			else return 1;
    		}
    		
    		public static void main(String[] args) {
    			Scanner input = new Scanner(System.in);
    			ComparableCircle c1 = new ComparableCircle();
    			System.out.println("输入第一个圆的半径");
    			double r1 = input.nextDouble();
    			c1.setRadius(r1);
    			ComparableCircle c2 = new ComparableCircle();
    			System.out.println("输入第二个圆的半径");
    			double r2 = input.nextDouble();
    			c2.setRadius(r2);
    			if(c1.compareTo(c2) < 0)System.out.println("两圆中的较大者为第二个,面积为" + c2.getArea());
    			else if(c1.compareTo(c2) == 0)System.out.println("两圆等大,面积为" + c2.getArea());
    			else System.out.println("两圆中的较大者为第一个,面积为" + c1.getArea());
    		}
    
    }
    
    3)experiment3
    GeometricObject类:见experiment1
    Colorable接口
    public interface Colorable {
    	public abstract void howToColor();
    }
    Square类
    import java.util.Random;
    public class Square extends GeometricObject implements Colorable{
    	private boolean canbecolored;
    	private double side;
    	public double getSide() {
    		return side;
    	}
    	public void setSide(double side) {
    		this.side = side;
    	}
    	@Override
    	public void howToColor(){
    		System.out.println("给所有的四条边着色");
    	}
    	@Override
    	public double getArea() {
    		return side * side;
    	}
    	@Override
    	public double getPerimeter() {
    		return 4 * side;
    	}
    	public void setCanbecolored(boolean canbecolored) {
    		this.canbecolored = canbecolored;
    	}
    	public boolean getCanbecolor() {
    		return canbecolored;
    	}
    	
    	public static void main(String[] args) {
    		Random random = new Random();
    		GeometricObject[] geometricObjects = new Square[5];
    		for(int i = 0; i < 5;i++){
    			geometricObjects[i] = new Square();
    			((Square)geometricObjects[i]).setCanbecolored(random.nextBoolean());
    		}
    		for(int i = 0; i < 5;i++){
    			System.out.println("第" + (i+1) + "个对象");
    			if(((Square)geometricObjects[i]).getCanbecolor()){
    				((Square)geometricObjects[i]).howToColor();
    			}
    			else System.out.println("不可着色");
    		}
    	}
    
    	
    }
    
    4)experiment4:附加题
    Max类
    import java.util.Date;
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.Scanner;
    
    public class Max {
    	public static Object max(Comparable[] a){
    		if(a[0] instanceof String){
    			String max = (String)a[0];
    			for(int i = 1; i < a.length;i++){
    				if(a[i].compareTo(max) > 0)max = (String)a[i];
    			}
    			return max;
    		}
    		if(a[0] instanceof Date){
    			Date max = (Date)a[0];
    			for(int i = 1;i < a.length;i++){
    				if(a[i].compareTo(max) > 0)max = (Date)a[i];
    			}
    			return max;
    		}
    		if(a[0] instanceof Integer){
    			int max = (Integer)a[0];
    			for(int i = 1;i < a.length;i++){
    				if(a[i].compareTo(max) > 0)max = (Integer)a[i];
    			}
    			return max;
    		}
    		return null;
    	}
    	public static void main(String[] args) throws ParseException {
    		Scanner input = new Scanner(System.in);
    		Integer[] num = new Integer[10];
    		String[] strings = new String[10];
    		SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd");
    		Date[] dates = new Date[10];
    		System.out.println("请输入十个整数: ");
    		for(int i = 0; i < 10;i++){
    			num[i] = input.nextInt();
    		}
    		System.out.println("请输入十个字符串: ");
    		for(int i = 0; i < 10;i++){
    			strings[i] = input.next();
    		}
    		System.out.println("请输入十个时间: ");
    		for(int i = 0; i < 10;i++){
    			dates[i] = new Date();
    			dates[i] = simpleDateFormat.parse(input.next());
    		}
    		input.close();
    		int max1 = (int)max(num);
    		String max2 = (String)max(strings);
    		Date max3 = (Date)max(dates);
    		System.out.println("最大整数为: " + max1);
    		System.out.println("最大字符串为: " + max2);
    		System.out.println("最大日期为: " + max3);
    	}
    	
    }
    
    
    展开全文
  • Java - 抽象类和接口

    2018-09-25 12:57:06
    1、抽象类抽象类用关键字abstract修饰,简单的说,抽象类是一个不能实例化的类,它可以具有抽象方法或者普通方法 抽象类优势: 抽象类可以将已经实现的方法提供给其子类使用,使代码可以被复用 抽象类中的抽象...

    1、抽象类:抽象类用关键字abstract修饰,简单的说,抽象类是一个不能实例化的类,它可以具有抽象方法或者普通方法

    抽象类优势:

    • 抽象类可以将已经实现的方法提供给其子类使用,使代码可以被复用
    • 抽象类中的抽象方法在子类中重写,保证了子类还具有自身的独特性
    • 抽象类指向其子类的对象,可以实现多态

    普通方法和抽象方法的区别:

    • 普通方法必须要有方法体,抽象方法不能有方法体(大括号也没有)
    • 抽象方法要用abstract修饰
    • 抽象方法必须存在于抽象类中
    • 普通类可以实例化,抽象类不能实例化

    2、接口:生活中的接口是指某些企业和组织等制定的一种约定或标准(如USB),java中的接口是一种约定,规定了实现该接口的类必须遵循一定规则,规则体现在“抽象方法”上,使得实现接口的类在形式上保持一致。所以说:接口是抽象方法的集合。如果一个类实现了某个接口,那么它就继承了这个接口的抽象方法,用关键字implements实现。

    接口中可以含有 变量和方法。接口中的变量会被隐式地指定为public static final变量;而方法会被隐式地指定为public abstract方法;并且接口中所有的方法不能有具体的实现,也就是说,接口中的方法必须都是抽象方法。

    从这里可以隐约看出接口和抽象类的区别,接口是一种极度抽象的类型,它比抽象类更加“抽象”。接口和抽象类一样,不能实例化。

    定义接口:

    public  interface [接口名] {
          //抽象方法
    }

    实现接口:

    public [类名]  implements [接口] {
          // 实现接口的方法
          //普通方法
    } 
    

     注意:一个类实现一个接口,则要求实现接口中的所有方法。

     

    3、接口和抽象类的区别:

    public abstract class Person{
    	//抽象方法
    	//普通方法
    }
    
    public interface Person{
          //抽象方法
    }
    • 抽象类使用abstract声明,接口使用interface声明
    • 抽象类可以包含抽象方法(必须使用abstract关键字)和普通方法
    • 接口只能包含抽象方法(无须使用abstract关键字)
    • 一个类只能继承一个父类,但能同时实现多个接口,也可以同时继承抽象类和实现接口

    4、接口 多实现

    一个类只能继承一个父类,但能同时实现多个接口,也可以同时继承抽象类和实现接口。

    class 类名 extends 父类名 implements 接口1,接口2,……{
            //类的成员
    }

     extends 必须位于implements 之前,一个类实现多个接口,要求实现多个接口中的方法。

    5、 面向对象的设计原则

    • 摘取出代码中变化的行为,形成接口
    • 多用组合,少用继承
    • 针对接口编程,不依赖于具体实现
    • 针对扩展开放,针对改变关闭

    实验:某人是软件工程师,能编写代码,完成项目功能,又是音乐家,能作曲唱歌,如何用java代码体现?

    • 分析:定义人类作为抽象父类,包含人的基本属性和行为;定义编程接口,拥有编程能力;定义作曲接口,拥有作曲能力等;定义一个子类,继承人类,同时实现编程接口和作曲接口。
    • Human类:封装Human类,用private修饰属性,定义人类公有的属性name,age,sex;公有的方法work(),并提供set和get方法以及构造器。
    package com.liudm.test5;
    
    public abstract class Human {
    	private String name;
    	private int age;
    	private char sex;
    	public abstract void work();
    	
    	public Human() {
    		// TODO Auto-generated constructor stub
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public int getAge() {
    		return age;
    	}
    	public void setAge(int age) {
    		this.age = age;
    	}
    	public char getSex() {
    		return sex;
    	}
    	public void setSex(char sex) {
    		this.sex = sex;
    	}
    }
    

    Programe类:抽象方法,完成编程功能的定义

    package com.liudm.test5;
    
    public interface Programe {
    	public void programing();
    
    }
    

    Compose类:抽象方法,完成作曲家的功能定义

    package com.liudm.test5;
    
    public interface Compose {
    	public void sing();
    }
    

    Person类:新建Person,该类继承Human抽象类,让他实现Programe、Compose接口,重写抽象方法,从而通过代码的形式体现了人对象拥有了很多能力。

    package com.liudm.test5;
    
    public class Person extends Human implements Programe,Compose{
    	public void work(){
    		System.out.println("人都要工作");
    	}
    	public void programing(){
    		System.out.println("有的人会编程");
    	}
    	public void sing(){
    		System.out.println("有的人会唱歌");
    	}
    }
    

    Test类:

    package com.liudm.test5;
    
    public class Test {
    	public static void main(String[] args) {
    		Human man = new Person();
    		man.work();
    		Person per = (Person)man;
    		per.programing();
    		per.sing();
    	}
    }
    


    练习1: 需求说明:实现某公司各种岗位(经理、销售人员、普通员工)的员工薪水计算,输出不同岗位各一名员工的工资。要求使用抽象类实现。
    分析:定义员工抽象类,具有计算薪水的抽象方法;定义子类:经理类、销售人员类、普通员工类,分别继承员工抽象类,重写计算薪水的方法;定义测试类,包含输出薪水的方法,参数为员工对象(抽象父类的引用指向子类的对象,实现多态)。

     Staff类:

    package com.liudm.demo8;
    
    public abstract class Staff {
    	private double salary;
    	public abstract void Wage();
    	
    	public Staff(){
    		super();
    	}
    	public void Staff(double salary){
    		this.salary = salary;
    	}
    	public double getSalary() {
    		return salary;
    	}
    	public void setSalary(double salary) {
    		this.salary = salary;
    	}
    }
    

    Manager类:

    package com.liudm.demo8;
    
    public class Manager extends Staff{
    	@Override
    	public void Wage() {
    		// TODO Auto-generated method stub
    		System.out.println("经理的薪水是:" + (this.getSalary() + 3000));
    	}
    }
    

    Saler类:

    package com.liudm.demo8;
    
    public class Saler extends Staff{
    	@Override
    	public void Wage() {
    		// TODO Auto-generated method stub
    		System.out.println("销售人员的薪水是:" + (this.getSalary() + 2000));
    	}
    
    }
    

    Employee类:

    package com.liudm.demo8;
    
    public class Employee extends Staff{
    	@Override
    	public void Wage() {
    		// TODO Auto-generated method stub
    		System.out.println("普通员工的薪水是:" + (this.getSalary() + 1000));
    	}
    
    }
    

    测试类:

    package com.liudm.demo8;
    
    public class StaffTest {
    	public static void main(String[] args) {
    		Staff manager = new Manager();
    		Staff saler = new Saler();
    		Staff employee = new Employee();
    		
    		manager.setSalary(7000);
    		manager.Wage();
    		saler.setSalary(5000);
    		saler.Wage();
    		employee.setSalary(3000);
    		employee.Wage();
    		
    	}
    }
    

     

    练习2: 需求说明:在职研究生既要学习,还要工作,使用实现多个接口的方式定义研究生类
    分析:定义人类作为抽象父类,包含人的基本属性和行为;定义学习接口,拥有学习能力;定义工作接口,拥有工作能力等;定义研究生类,继承人类,同时实现学习接口和工作接口。

    Person类:

    package com.liudm.demo9;
    
    public abstract class Person {
    	private String name;
    	private int age;
    	private char sex;
    	
    	public Person(){
    		super();
    	}
    	public Person(String name,int age,char sex){
    		super();
    		this.name = name;
    		this.age = age;
    		this.sex = sex;
    	}
    	
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public int getAge() {
    		return age;
    	}
    	public void setAge(int age) {
    		this.age = age;
    	}
    	public char getSex() {
    		return sex;
    	}
    	public void setSex(char sex) {
    		this.sex = sex;
    	}
    }
    

    Study接口:

    package com.liudm.demo9;
    
    public interface Study {
    	public void Study();
    }
    

    Work接口:

    package com.liudm.demo9;
    
    public interface Work {
    	public void Work();
    }
    

    Student类:

    package com.liudm.demo9;
    
    public class Student extends Person implements Study,Work{
    //	public void Student(String name,int age,char sex){
    //		super(name,age,sex);
    //	}
    
    	@Override
    	public void Study() {
    		// TODO Auto-generated method stub
    		System.out.println(this.getName() + "\t" + this.getAge() + "\t" + this.getSex() + "\t" + "能够学习");
    	}
    	@Override
    	public void Work() {
    		// TODO Auto-generated method stub
    		System.out.println(this.getName() + "\t" + this.getAge() + "\t" + this.getSex() + "\t" + "能够工作");
    	}
    }
    

    测试类:

    package com.liudm.demo9;
    
    public class PerTest {
    	public static void main(String[] args) {
    		Student stu1 = new Student();
    		Student stu2 = new Student();
    		stu1.setName("Sara");
    		stu1.setAge(20);
    		stu1.setSex('女');
    		stu2.setName("Jonson");
    		stu2.setAge(24);
    		stu2.setSex('男');
    		
    		stu1.Study();
    		stu2.Work();
    	}
    }
    

    练习3: 教练和运动员案例:乒乓球运动员和篮球运动员;乒乓球教练和篮球教练。 为了出国交流,跟乒乓球相关的人员都需要学习英语。
    请用所学知识分析:这个案例中有哪些抽象类,哪些接口,哪些具体类。
    分析:
    1) 共同的属性:姓名 年龄;共同的方法:吃饭,睡觉(其中吃饭的内容两者不同,所以用抽象方法);不同的方法:队员练习,教练教导,分别写入队员类和教练类
    2) 接口:学习英语
    3) 抽象类:人类;  运动员类、教练类 这两个继承人类;具体类:乒乓球队员类、教练类和篮球队员类、教练类 ; 分别继承运动员类或教练类,其中乒乓球有关的扩展学习英语接口

     

    展开全文
  • (1) 定义继承抽象类 对程序进行编译,分析错误原因。 抽象方法没有方法体,并且含有抽象方法的类只能是抽象类抽象类不能被实例化为对象,在具体应用中需要被继承。 因此,这里出错的原因是类型 Test 必须...
  • java 抽象类和接口的一点实验

    千次阅读 2010-07-11 10:03:00
     一个抽象类,该抽象类中引用一个接口变量,同时,定义一个抽象方法abstract public doAct();该抽象类采用2种注入方式的其中一种:  一: 在该抽象类中定义一个方法,该方法接受一个字符串参数,在该...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 21,540
精华内容 8,616
关键字:

java实验抽象类和接口

java 订阅