第七周课程总结&实验报告（五）

实验报告（五）

抽象类的使用

设计一个类层次，定义一个抽象类--形状，其中包括有求形状的面积的抽象方法。继承该抽象类定义三角型、矩形、圆。分别创建一个三角形、矩形、圆存对象，将各类图形的面积输出。
注：三角形面积s=sqrt(p*(p-a)*(p-b)*(p-c)) 其中，a,b,c为三条边，p=(a+b+c)/2

2.编程技巧

(1) 抽象类定义的方法在具体类要实现；

(2) 使用抽象类的引用变量可引用子类的对象；

(3) 通过父类引用子类对象，通过该引用访问对象方法时实际用的是子类的方法。可将所有对象存入到父类定义的数组中。

实验代码：

package 实验包;
import java.util.Scanner;
public abstract class shape {
       public abstract double print();
}
public  class triangle extends shape{
    
    private double a;
    private double b;
    private double c;
    public triangle(double a,double b,double c) {
        this.a=a;
        this.b=b;
        this.c=c;
    }
    public double getA() {
        return a;
    }
    public void setA(double a) {
        this.a = a;
    }
    public double getB() {
        return b;
    }
    public void setB(double b) {
        this.b = b;
    }
    public double getC() {
        return c;
    }
    public void setC(double c) {
        this.c = c;
    }
    public  double print(){
        double p=(this.a+this.b+this.c)/2;
        return Math.sqrt(p*(p-this.a)*(p-this.b)*(p-this.c));
    }
}
public class rectangle extends shape{

    private double length;
    private double broad;
    public rectangle(double length,double broad){
        this.length=length;
        this.broad=broad;
        
    }
    public double getLength() {
        return length;
    }
    public void setLength(double length) {
        this.length = length;
    }
    public double getBroad() {
        return broad;
    }
    public void setBroad(double broad) {
        this.broad = broad;
    }
    public double print(){
         return broad*length;
    }
}
public class circle extends shape {

    
    private double r;
    public circle(double r) {
        this.r=r;
    }
    public double getR() {
        return r;
    }
    public void setR(double r) {
        this.r = r;
    }
    public double print() {
        return Math.PI*r*r;
    }
  
}public class test {
        public static void main(String args[]) {
            int f=0;
            while(f==0) {
            System.out.println("请输入三角形的边长：");
            Scanner s=new Scanner(System.in);
            double a=s.nextDouble();
            double b=s.nextDouble();
            double c=s.nextDouble();
            triangle triangle=new triangle(a,b,c);
            if(a>0&&b>0&&c>0&&a+b>c&&a+c>b&&b+c>a) {
                System.out.println("三角形的面积为："+triangle.print());
                f=1;
            }
            else {
                System.out.println("此输入不符合三角形的定义，请重输");
            }
        }
            while(f==1) {
            System.out.println("请输入矩形的长和宽：");
            Scanner h=new Scanner(System.in);
            double length=h.nextDouble();
            double broad=h.nextDouble();
            rectangle rectangle=new rectangle(length,broad);
            if(length>0&&broad>0) {
                System.out.println("矩形的面积为："+rectangle.print());
                f=2;
            }else {
                System.out.println("此输入不符合矩形定义，请重输：");
                }
            }
            while(f==2) {
            System.out.println("请输入圆的半径：");
            Scanner g=new Scanner(System.in);
            double r=g.nextDouble();
            circle circle=new circle(r);
            if(r>0) {
                System.out.println("圆的面积为："+circle.print());
                f=3;
            }else {
                System.out.println("此输入不符合圆的定义，请重输：");
                }
            }
            
                     
        }
        
}

结果截图：

使用接口技术

1定义接口Shape，其中包括一个方法size（）,设计“直线”、“圆”、类实现Shape接口。分别创建一个“直线”、“圆”对象，将各类图形的大小输出。

编程技巧

(1) 接口中定义的方法在实现接口的具体类中要重写实现；

(2) 利用接口类型的变量可引用实现该接口的类创建的对象。

实验代码：

package ddd;

public interface shape {
    public abstract double print();
}
public class line implements shape{

    
    private double x1,y1,x2,y2;
    public line(double x1,double x2,double y1,double y2) {
        this.x1 =x1;
        this.x2=x2;
        this.y1=y1;
        this.y2=y2;
    }
    public double getX1() {
        return x1;
    }
    public void setX1(double x1) {
        this.x1 = x1;
    }
    public double getY1() {
        return y1;
    }
    public void setY1(double y1) {
        this.y1 = y1;
    }
    public double getX2() {
        return x2;
    }
    public void setX2(double x2) {
        this.x2 = x2;
    }
    public double getY2() {
        return y2;
    }
    public void setY2(double y2) {
        this.y2 = y2;
    }
    public double print(){
        return Math.sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1));
    }
}
public class circle implements shape {

    
    private double r;
    public circle(double r) {
        this.r =r;
    }
    public double getR() {
        return r;
    }
    public void setR(double r) {
        this.r = r;
    }
    public double print() {
        return Math.PI *r*r;
    }
    
}
package ddd;
import java.util.Scanner;
public class text {
     public static void main(String[] arge) {
         System.out.println("请输入点的坐标：");
         Scanner s=new Scanner(System.in);
         double x1=s.nextDouble();
         double y1=s.nextDouble();
         double x2=s.nextDouble();
         double y2=s.nextDouble();
         line line=new line(x1,y1,x2,y2);
         System.out.println("两点之间的距离为："+line.print());
         int f=0;
         while(f==0) {
         System.out.println("请输入圆的半径：");
         Scanner g=new Scanner(System.in);
         double r=g.nextDouble();
         circle circle=new circle(r);
         if(r>0) {
             System.out.println("圆的面积为："+circle.print());
             f=1;
         }
         else {
             System.out.println("此输入不符合圆的定义，请重输：");
         }
         }
     }
}

结果截图：

课程总结

这周学习抽象类与接口的应用：为抽象类与接口实例化，相比来说，接口中所有的方法必须是抽象方法；
接口没有构造方法，不能用于实例化对象。抽象类都要被继承，有子类覆写，更详细的进行输出；
一个类可以同时实现多个接口；一个类只能继承一个类，但是能实现多个接口。一个接口能继承另一个接口，这和类之间的继承比较相似；
抽象类和接口都不能直接实例化，如果要实例化，抽象类变量必须指向实现所有抽象方法的子类对象，接口变量必须指向实现所有接口方法的类对象。
抽象类要被子类继承，接口要被类实现；
接口只能做方法申明，抽象类中可以做方法申明，也可以做方法实现，接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量；
抽象类里的抽象方法必须全部被子类所实现，如果子类不能全部实现父类抽象方法，那么该子类只能是抽象类；
同样，一个实现接口的时候，如不能全部实现接口方法，那么该类也只能为抽象类。
抽象方法只能申明，不能实现。abstract void abc();不能写成abstract void abc(){}，抽象类里可以没有抽象方法
如果一个类里有抽象方法，那么这个类只能是抽象类，抽象方法要被实现，所以不能是静态的，也不能是私有的
接口可继承接口，并可多继承接口，但类只能单根继承
还学习了Object类：一个类如果没有明显继承一个类则肯定是Object类