前言：

1.抽象类

1.1抽象类的概念及语法

1.2 抽象类的特征

1.3抽象类的特性

2.接口

2.1接口的概念及语法

2.2接口的使用及特性

2.2.1接口的使用

2.2.2接口的特性

2.3实现多个接口

2.4接口的继承

3.抽象类与接口的区别

结束语：

前言：

上一次小编讲解了继承、组合和多态，这次小编和大家分享一下抽象类与接口的知识点。

1.抽象类

1.1抽象类的概念及语法

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

1.2 抽象类的特征

关键字：abstract

通过abstract修饰的类就叫抽象类，通过abstract修饰的方法叫抽象方法。

代码如下所示：

package demo1;
//抽象类Test
public abstract class Test {
    public int a;//成员变量
    public void func1(){
        //普通方法
    }
    abstract public void func2();//抽象方法
}

注意：

被abstract修饰的方法不能有方法体。
抽象方法也是类，也可以有类的一般属性，可以有普通方法和属性，甚至构造方法。

1.3抽象类的特性

①抽象类不能直接实例化对象。

②抽象方法不被private、final和static修饰，因为被abstract修饰的方法需要在子类中重写，被修饰之后就不能重写了。

③抽象类必须要被继承，并且继承后子类要重写父类中的抽象方法，否则子类也是抽象类，必须要使用abstract修饰。

代码如下所示：

package demo1;
abstract class Shape{
   abstract public void draw();
   abstract void calcArea();
}
class Rect extends Shape{
    private double length;
    private double width;

    public Rect(double length, double width) {
        this.length = length;
        this.width = width;
    }

    @Override
    //该注释可以帮助我们检查重写代码的格式是否正确
    public void draw() {
        //子类必须重写父类的abstract修饰的方法
        System.out.println("矩形为：length=" + length + " width=" + width);
    }

    @Override
    void calcArea() {
        //子类必须重写父类的abstract修饰的方法
        System.out.println("矩形的面积为：" + length * width);
    }
}
public class Test2 {
    public static void main(String[] args) {
        Rect rect = new Rect(12,23);
        rect.draw();
        rect.calcArea();
    }
}

结果如下所示：

④抽象类中不一定包含抽象方法，但包含抽象的方法的类必须是抽象类。

⑥抽象类中可以有构造方法，供子类创建对象时，初始化父类的成员变量。

代码如下所示：

package demo1;
abstract class A{
    public int a;
    public int b;
    abstract public void func();

    public A(int a, int b) {
        this.a = a;
        this.b = b;
    }
}
class B extends A{

    public B(int a, int b) {
        super(a, b);
        //先帮助父类构造
    }

    @Override
    public void func() {
        System.out.println("对父类被abstract修饰的方法进行重写！");
    }
}
public class Test3 {
    public static void main(String[] args) {
        B b = new B(1,2);
        b.func();
    }
}

结果如下所示：

2.接口

2.1接口的概念及语法

接口就是公共的行为规范标准，大家在实现时，只要符合规范标准，就可以通用。在java中，接口也可以看做是：多个类的公共规范，是一种引用数据类型。

关键字：interface。

代码如下所示：

interface IUsb{
    //一个接口的定义
    void func();
}

注意：

创建接口时，接口的命名一般以大写字母I开头。
接口命名时一般使用“形容词”词性的单词。
阿里编码规范中约定，接口中的方法和属性不要加任何修饰符号，保持代码的简洁性。

2.2接口的使用及特性

2.2.1接口的使用

接口不可以直接使用，必须要有一个“实现类”来“实现”该接口，实现接口中的所有抽象方法。

关键字：implements

代码如下所示：

package demo2;

public class Test2 implements IUsb{
    @Override
    public void func() {
        //实现接口中的所有抽象方法
    }
}

注意：子类和父类直接是extends继承关系，类与接口之间是implements实现关系。

2.2.2接口的特性

①接口类型是一种引用类型，但是不能直接new接口的对象。

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

interface B{
    void func1();
    public abstract void func2();
    //其中func1和func2之前的修饰符都是一样的。
}

③接口中的方法是不能在接口中实现的，只能由实现接口的类来实现。

package demo2;
interface C{
    public abstract void func();
    //不可以在接口中实现该方法，而是应该在实现类中实现该方法！！！
//    public abstract void func2(){
//        System.out.println("接口中实现方法体！");
//    }
}
public class Test5 implements C{

    @Override
    public void func() {
        System.out.println("在实现类中实现！");
    }
}

④重写接口中方法时，不能使用默认的访问权限。

package demo2;
interface D{
    void func();
}
public class Test6 implements D {
    @Override
    void func() {
        System.out.println("不可以使用默认的访问权限！！！");
    }
//    @Override
//    public void func() {
//        System.out.println("使用public修饰的！！！");
//    }

}

⑤接口中可以含有变量，但是接口中的变量会被隐式的指定为public static final变量。

interface E{
    public static final int a = 10;//必须要给定默认值
    double b = 1.2;//默认是被public static final修饰的。
}

⑥接口中不能有静态代码块和构造方法。

interface F{
//    static {
//        //不能有静态代码块
//    }
    int a = 10;
    int b = 20;
    //不可以有构造代码块
//    public F(int a, int b) {
//        this.a = a;
//        this.b = b;
//    }
}

⑦接口虽然不是类，但是接口编译完成后字节码文件后缀格式也是.class。

⑧如果类没有实现接口中的所有的抽象方法，则该类必须设置为抽象类。

package demo2;
interface G{
    void func1();
    void func2();
    //如果类没有实现接口中的所有的抽象方法，则该类必须设置为抽象类。
}
public abstract class Test9 implements G{
    @Override
    public void func1() {
        //只实现一个抽象方法，则该类必须置为abstract
    }
}

⑨JDK8中：接口中还可以包含default方法。

interface H{
    //default void func3();在JDK8中可以。
}

2.3实现多个接口

在Java中，类和类之间是单继承的，一个类只能有一个父类，即Java中不支持多继承，但是一个类可以实现多个接口。

代码如下所示：

package demo3;
interface IEat{
    void eat();
}
interface IRunning{
    void run();
}
public class Animal {
    public String name;
    public int age;
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
class Cat extends Animal implements IEat,IRunning{
    //先继承，再实现。继承只能继承一个，实现可以实现多个接口
    public Cat(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println(name + "正在吃饭！");
    }

    @Override
    public void run() {
        System.out.println(name + "正在跑！");
    }

    public static void main(String[] args) {
        Cat cat = new Cat("咪咪",12);
        cat.eat();
        cat.run();
    }


}

结果如下所示：

注意：一个实现类实现多个接口的时候，每一个接口中的抽象方法都要实现，否则该类必须设置为抽象类。

2.4接口的继承

在java中，类和类之间是单继承，一个类可以实现多个接口，接口与接口之间可以多继承，即用接口可以达到多继承的目的。

关键字；extends。

代码如下所示：

package demo4;
interface IRunning{
    void run();
}
interface ISwimming{
    void swimming();
}
interface IFly extends IRunning,ISwimming{
    //实现了接口间的多继承
    void fly();
}
public class Animal {
    public String name;
    public int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
class Duck extends Animal implements IFly{

    public Duck(String name, int age) {
        super(name, age);
    }

    @Override
    public void run() {
        System.out.println(name + "正在跑！");
    }

    @Override
    public void swimming() {
        System.out.println(name + "正在游泳！");
    }

    @Override
    public void fly() {
        System.out.println(name + "正在飞");
    }

    public static void main(String[] args) {
        Duck duck = new Duck("阿飞",13);
        duck.fly();
        duck.run();
        duck.swimming();
    }
}

结果如下所示：