Java抽象类、接口

一、抽象类

1.1 概述

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

1.2 抽象类的特点

● 抽象类和抽象方法必须用abstract修饰

//抽象类的定义
public abstract class 类名(){
//抽象方法的定义
public abstract void 方法名();

}

要注意
● 抽象方法必须包含在抽象类中；

● 抽象方法：只写方法标签，不写方法体；方法名后面直接跟一个分号，而不是花括号。

● 抽象类不能实例化
如果想要使用抽象类，则需要通过抽象类的子类来创建对象；

● 抽象类的子类，要么重写抽象类的全部抽象方法；或者该子类也为抽象类；

● 抽象类中，并不一定包含抽象方法。
抽象方法一定在抽象类中，但是抽象类可同时拥有抽象方法和非抽象方法；

以下代码所示便是一个简单的抽象类：

public abstract class Person {
    String name;
    int age;
    String sex;

    public Person(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    public Person() {
    }

    public abstract void work();

    public abstract  void hello();
}
//子类Student
public class Student extends Person{

    @Override
    public void work() {
        System.out.println("认真学习");
    }

    @Override
    public void hello() {
        System.out.println("老师好");

    }
}
//子类Teacher
public class Teacher extends Person{
    @Override
    public void work() {
        System.out.println("教书育人");
    }

    @Override
    public void hello() {
        System.out.println("同学好");

    }
}

//测试类
public class Demo {
    public static void main(String[] args) {
        Person a1 = new Teacher();
        a1.name = "dragon";
        a1.age = 30;
        a1.sex = "男";
        Person a2 = new Student();
        a2.name = "jungle";
        a2.age = 22;
        a2.sex = "男";

        a1.work();
        a1.hello();

        a2.work();
        a2.hello();
    }

}

运行结果：

教书育人
同学好
认真学习
老师好

1.3抽象类总结规定

1. 抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

2. 抽象类不能被实例化，如果被实例化，就会报错，编译无法通过。只有抽象类的非抽象子类可以创建对象。

3. 抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类。

4. 抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现也就是方法的具体功能。

二、接口

2.1 概述

在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。

2.2接口的特点

● 接口中每一个方法都是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。

● 接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。

● 接口中的方法是不能在接口中实现的（与抽象方法一样只写方法标签，不写方法体），只能由实现接口的类来实现接口中的方法。

2.3接口与类的相似点

● 都可以拥有abstrac修饰的抽象方法。

● 都能被"继承"；抽象类的继承类叫做子类，接口的继承类叫做实现类；

2.4接口与类的区别

● 接口不能用于实例化对象。

● 接口没有构造方法。

● 接口中所有的方法必须是抽象方法。

● 接口不能包含成员变量，除了 static 和 final 变量。

● 接口不是被类继承了，而是要被类实现。

● 接口支持多继承(一个实现类可以实现多个接口，同时还可以继承一个父类)。

2.5实例演示

//定义一个接口
public interface CompareObject {
    public int compareTo(Object o);
}

//定义一个父类
public class Circle {
    double redius;

    public double getRedius() {
        return redius;
    }

    public void setRedius(double redius) {
        this.redius = redius;
    }

}
//定义子类和实现类
public class ComparableCircle extends Circle implements CompareObject{

    @Override
    public int compareTo(Object o) {
        int a = Double.compare(this.getRedius(), ((Circle) o).getRedius());
        return a;
    }
}

//测试类
public class InterfaceTest {
    public static void main(String[] args) {
        ComparableCircle c1 = new ComparableCircle();
        ComparableCircle c2 = new ComparableCircle();
        c1.setRedius(5);
        c2.setRedius(4);
        int a = c1.compareTo(c2);
        System.out.println(a);
        size(a);
    }
    public static void size(int a){
        if (a==0){
            System.out.println("相等");
        }
        else if (a==1){
            System.out.println("当前对象大");
        }else {
            System.out.println("当前对象小");
        }
    }
}

运行结果为：

1
当前对象大

注意点：
重写接口中声明的方法时，需要注意以下规则：

   类在实现接口的方法时，不能抛出强制性异常，只能在接口中，或者继承接口的抽象类中抛出该强制性异常。
  
   类在重写方法时要保持一致的方法名，并且应该保持相同或者相兼容的返回值类型。
    
   如果实现接口的类是抽象类，那么就没必要实现该接口的方法。

在实现接口的时候，也要注意一些规则：

   一个类可以同时实现多个接口。
   
   一个类只能继承一个类，但是能实现多个接口。
   
   一个接口能继承另一个接口，这和类之间的继承比较相似。