JAVA抽象类

抽象类

1.什么是抽象方法

没有方法体，用abstract修饰

不需要具体的实现，只需要声明就行了

2.什么是抽象类

由abstract修饰的类叫抽象类

注：

​ 一个类有抽象方法这类一定是抽象类

​ 抽象类可以没有抽象方法的实现，可以有非抽象方法

​ 抽象类不能实例化

public abstract class Square {
    public abstract void show();

}

3.怎么去使用抽象类

通过继承去实现抽象类中的所有抽象方法

4.抽象类之间的继承关系

抽象类可以继承抽象类

但其子类必须实现继承的类的所有抽象方法

为了避免矛盾fianl不能和abstract一起修饰类

案例

一个抽象图形类，有面积和周长的抽象方法，

长方形类和圆类分别继承图形类实现面积和周长的方法

/**
 * 图形类
 */
public abstract class Graph {
    public abstract double area();//计算面积
    public abstract double perimeter();//计算周长
}


/**
 * Square类 继承抽象类 Graph 实现长方形的面积和周长的计算
 */
public class Square extends Graph{
    private double length;//长
    private double width;//宽

    //无惨构造方法
    public Square(){

    }

    /**
     * 有参构造方法 初始化长方形的长和高
     * @param length
     * @param width
     */
    public Square(double length,double width){
        this.length = length;
        this.width = width;
    }

    /**
     * 实现长方形面积计算
     * @return 面积
     */
    @Override
    public double area() {
        return this.length * this.width;
    }

    /**
     * 实现长方形周长计算
     * @return 周长
     */
    @Override
    public double perimeter() {
        return (this.length * 2) + (this.width * 2);
    }
}


/**
 * Circle类 继承抽象类 Graph 实现圆面积和周长的计算
 */

public class Circle extends Graph {
    private double r;
    //无惨构造方法
    public Circle(){

    }

    /**
     * 对r进行初始化
     * @param r
     */
    public Circle(double r){
        this.r = r;
    }
    public void setR(double r){
        this.r = r;
    }
    public double getR(){
        return r;
    }

    /**
     * 实现圆的面积计算
     * @return 面积
     */
    @Override
    public double area() {
        return 3.14 *  r * r;
    }

    /**
     * 实现圆的周长计算
     * @return 周长
     */
    @Override
    public double perimeter() {
        return 2 * r * 3.14;
    }
}


/**
 * 主页面控制
 * 用户选择，计算长方形的面积和计算圆的面积
 */
public class MainCalcula {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (true){
            System.out.println("*****************************");
            System.out.println("      1--计算长方形面积和周长");
            System.out.println("      2--计算圆形面积和周长");
            System.out.println("      0--退出");
            System.out.println("*****************************");

            System.out.println("请输入对应数字进行操作：");
            int date = sc.nextInt();

            switch(date){
                case 1:
                    System.out.println("请输入长：");
                    double length = sc.nextDouble();
                    System.out.println("请输入宽");
                    double width = sc.nextDouble();
                    Square sq = new Square(length,width);//声明长方形对象
                    System.out.println("长方形的面积为：" + sq.area());
                    System.out.println("长方形的周长为：" + sq.perimeter());
                    break;

                case 2:
                    System.out.println("请输入半径：");
                    double r = sc.nextDouble();
                    Circle ci = new Circle(r);//声明圆对象
                    System.out.println("圆的面积为：" + ci.area());
                    System.out.println("圆的周长为：" + ci.perimeter());
                    break;
                case 0:
                    break;
                default:
                    System.out.println("选择输入错误！");
                    break;
            }
            if(date == 0){
                break;//退出
            }
        }
        System.out.println("程序退出！");
    }
}

接口

1.接口—interface定义的接口

• 接口中的方法没有修饰时默认为 public abstract修饰的

• 接口中的属性都为常量默认为 public static final 修饰的

• 接口是一种特殊的抽象类，他的功能性更加的”纯粹“

• 接口也不能实例化

• public interface UserAod {
      boolean USER_LOGIN = true;//定义常量
      void addUser();//声明方法
  }
  

2.怎么用接口

​ 实现类通过impelments关键字实现定义在接口中的方法
​ 实现类必须实现接口定义的所有方法
​ 接口与接口可以继承，同样实现类在实现是必须实现其所有关系的方法
​ 接口可以实现多实现接口的方式，一个实现类可以实现多个接口

3.接口和抽象类的区别

• 相同点

  （1）都不能被实例化

  （2）接口的实现类或抽象类的子类都必须实现所声明的抽象方法

• 不同点

  （1）接口只有定义，不能有方法的实现，java 1.8中可以定义default方法体，而抽象类可以实现方法

  （2）实现接口的关键字为implements，抽象类的是通过继承关键字extends。一个类只能继承一个类，一个类可以实现多个接口。

  （3）接口中的成员变量默认为常量，不能使用其它修饰符修饰；抽象类中可以为普通的成员变量，可以使用public等等修饰。

  （4）接口强调特定的功能实现，而抽象类抢到所属关系。（核心思想）