java-类的继承和接口使用

1. 实验目的

（1）理解抽象类与接口的使用；
（2）了解包的作用，掌握包的设计方法。

2. 实验要求

（1）掌握使用抽象类的方法。
（2）掌握使用系统接口的技术和创建自定义接口的方法。
（3）了解 Java 系统包的结构。
（4）掌握创建自定义包的方法。

3. 实验内容

（一）抽象类的使用

1. 设计一个类层次，定义一个抽象类–形状，其中包括有求形状的面积的抽象方法。 继承该抽象类定义三角型、矩形、圆。 分别创建一个三角形、矩形、圆存对象，将各类图形的面积输出。
   注：三角形面积s=sqrt(p*(p-a)(p-b)(p-c)) 其中，a,b,c为三条边，p=(a+b+c)/2*
   2.编程技巧
   (1) 抽象类定义的方法在具体类要实现；
   (2) 使用抽象类的引用变量可引用子类的对象；
   (3) 通过父类引用子类对象，通过该引用访问对象方法时实际用的是子类的方法。可将所有对象存入到父类定义的数组中。
   （二）使用接口技术
   1定义接口Shape，其中包括一个方法size（）,设计“直线”、“圆”、类实现Shape接口。分别创建一个“直线”、“圆”对象，将各类图形的大小输出。
   2.编程技巧
   (1) 接口中定义的方法在实现接口的具体类中要重写实现；
   (2) 利用接口类型的变量可引用实现该接口的类创建的对象。

4. 实验源码

（一）抽象类

package 实验报告五.抽象类;
/**
 * @program: JavaWork
 * @description: 设计一个类层次，定义一个抽象类--形状，其中包括有求形状的面积的抽象方法。 继承该抽象类定义三角型、矩形、圆。 分别创建一个三角形、矩形、圆存对象，将各类图形的面积输出。
 * @author: Tom里的同学
 * @create: 2021-11-14 -14:43
 */
import java.util.Scanner;
abstract class Shape{
    Scanner sc=new Scanner(System.in);
    String name;
    abstract void Area();
}
class Trangle extends Shape{//三角形

    double a,b,c;
    boolean bool;
    public Trangle(){
        System.out.print("请输入构成三角形的三边：");
        a=sc.nextDouble();
        b=sc.nextDouble();
        c=sc.nextDouble();
        this.name="三角形";
        if(a+b>c&&a+c>b&&b+c>a){
            System.out.println("能构成三角形");
            bool=true;
        }
        else
        {
            System.out.println("无法构成三角形");
            bool=false;
        }
    }
    public void Area(){
        if(bool){
            double p=(a+b+c)/2;
            double s=Math.sqrt((p-a)*(p-b)*(p-c));
            System.out.println("三角形面积为："+s);
        }else {
            System.out.println("无法计算面积！");
        }
    }
}
class Rectangle extends Shape{
    double a,b;
    double s;
    public Rectangle(){
        System.out.print("请输入构成矩形的长宽：");
        a=sc.nextDouble();
        b=sc.nextDouble();
        if(a>0&&b>0)
        if(a==b)
            this.name="正方形";
        else
            this.name="矩形";
        else
            System.out.println("输入非法！");
    }
    public void Area(){
        s=a*b;
        System.out.println(this.name+"的面积是："+s);

    }
}
class Circular extends Shape{
    double r,s;
    public Circular(){
        System.out.print("请输入半径：");

        r=sc.nextDouble();

        if(r>0)
        {
            this.name="圆";
        }else
            System.out.println("半径输入非法！");
    }
    public void Area(){
        s=Math.PI*Math.pow(r,2);
        System.out.println(this.name+"的面积为："+s);
        }
}
public class Area{
    public static void main(String[] args) {
        Trangle tra=new Trangle();
        tra.Area();
        Rectangle rec=new Rectangle();
        rec.Area();
        Circular cir=new Circular();
        cir.Area();
    }
}

（二）接口

创建接口

public interface Shape {
    public abstract double size();
}

圆类

public class circular implements Shape{
    double r;

    circular (double r){
        this.r=r;
    }
    public double size(){
        return Math.PI*Math.pow(r,2);
    }
}

直线类

public class Line implements Shape {
    double l;
    Line(double l){
        this.l=l;
    }
    public double size(){
        return l;
    }
}

import java.util.Scanner;

public class Output {
   public static void main(String[] args) {
      Scanner sc=new Scanner(System.in);
      double l,r;
      System.out.print("输入直线长度：");
      l=sc.nextDouble();
      Line line=new Line(l);
      System.out.println("直线的长度："+line.size());
      System.out.print("输入圆的半径：");
      r=sc.nextDouble();
      circular cir=new circular(r);
      System.out.println("圆的面积："+cir.size());

   }
}

5. 结论

（一）抽象类定义：

abstract class 抽象类名称{
	属性;
	public void println(){;//普通方法
(内容);
}
	public abstract void print();//抽象方法
}

抽象类不能直接创建对象，必须被子类继承，并且不是抽象类的子类必须要覆写抽象类中的全部抽象方法。抽象类和抽象方法都是使用abstract关键字声明的。在抽象类中的抽象方法只需声明不需要实现；抽象方法不能使用private声明，因为abstract声明的方法必须要子类进行覆写，而private声明的方法无法被子类覆写。

（二）接口定义：

Interface 接口名称{
全局常量;
抽象方法;
}

public权限的问题：
在接口中如果不写public，也是public访问权限；

实现接口：
关键字：implements

class子类 implements 接口A，接口B...{
}

接口摆脱了java的单继承局限