前言

上一篇已经讲过包、继承和多态，链接如下：

下面会给各位老铁总结面向对象编程的最后两个知识点： 抽象类和接口。

一、（补充）在构造方法中调用重写的方法（坑）

一段有坑的代码. 我们创建两个类, B 是父类, D 是子类. D 中重写 func 方法. 并且在 B 的构造方法中调用 func。

class B {
    public B() {
        // do nothing
        func();
    }

    public void func() {
        System.out.println("B.func()");
    }
}

class D extends B {
    private int num = 1;

    @Override
    public void func() {
        System.out.println("D.func() " + num);
    }
}

public class Test {
    public static void main(String[] args) {
        D d = new D();
    }
}

程序执行结果如下：

✦ 构造 D 对象的同时, 会调用 B 的构造方法.
✦ B 的构造方法中调用了 func 方法, 此时会触发动态绑定, 会调用到 D 中的 func().
✦ 此时 D 对象自身还没有构造, 此时 num 处在未初始化的状态, 值为 0.

结论: “用尽量简单的方式使对象进入可工作状态”, 尽量不要在构造器中调用方法(如果这个方法被子类重写, 就会触发动态绑定, 但是此时子类对象还没构造完成), 可能会出现一些隐藏的但是又极难发现的问题。

二、抽象类

2.1 语法规则

在上篇打印图形例子中, 我们发现, 父类 Shape 中的 draw 方法好像并没有什么实际工作, 主要的绘制图形都是由Shape 的各种子类的 draw 方法来完成的. 像这种没有实际工作的方法, 我们可以把它设计成一个抽象方法(abstract method), 包含抽象方法的类我们称为抽象类(abstract class).

abstract class Shape { 
 abstract public void draw(); 
}

★ 在 draw 方法前加上 abstract 关键字, 表示这是一个抽象方法. 同时抽象方法没有方法体(没有 { }, 不能执行具体代码).

★ 对于包含抽象方法的类, 必须加上 abstract 关键字表示这是一个抽象类（抽象方法指的是只有函数声明，没有函数实现的方法，如上代码）

2.2 注意事项

抽象类不能直接实例化，哪怕该类中一个抽象方法都没有。

Shape shape = new Shape(); 
// 编译出错
Error:(30, 23) java: Shape是抽象的; 无法实例化

抽象方法不能是 private 的，因为子类无法重写。

abstract class Shape { 
 abstract private void draw(); 
} 
// 编译出错
Error:(4, 27) java: 非法的修饰符组合: abstract和private

抽象类中可以包含其他的非抽象方法, 也可以包含字段. 这个非抽象方法和普通方法的规则都是一样的, 可以被重写,也可以被子类直接调用

abstract class Shape { 
 abstract public void draw(); 
 void func() { 
 System.out.println("func"); 
 } 
} 
class Rect extends Shape { 
 ... 
} 
public class Test { 
 public static void main(String[] args) { 
 Shape shape = new Rect(); 
 shape.func(); 
 } 
} 
// 执行结果
func

抽象方法所在的类必须是抽象类，子类若继承了抽象类，必须覆写所有的抽象方法（子类是普通类的情况下），抽象类也可以被抽象类继承，此时可以留给这个抽象类的子类去覆写。
题目：JAVA中没有方法体的方法就是抽象方法（✘）
本地方法也没有方法体，但它不是抽象方法。
抽象类是普通类的超集（普通类有的内容，抽象类都有），只是比普通类多了一些抽象方法而已，抽象类虽然没法直接实例对象，但是也可以存在构造方法，子类在实例化时，仍然遵从继承原则，先调用父类（抽象类）的构造方法，而后调用子类的构造方法！！！

输出num=0是因为print语句是在父类构造方法中完成的，此时还没进到子类的构造方法中，num还未初始化，默认值为0。

2.3 抽象类的作用

✦抽象类存在的最大意义就是为了被继承.
✦抽象类本身不能被实例化, 要想使用, 只能创建该抽象类的子类. 然后让子类重写抽象类中的抽象方法。

✦使用抽象类相当于多了一重编译器的校验。
✦使用抽象类的场景就如上面的代码, 实际工作不应该由父类完成, 而应由子类完成. 那么此时如果不小心误用成父类了,使用普通类编译器是不会报错的.但是父类是抽象类就会在实例化的时候提示错误, 让我们尽早发现问题

✦很多语法存在的意义都是为了 “预防出错”, 例如 final 关键字也是类似. 创建的变量用户不去修改, 不就相当于常量嘛? 但是加上 final 能够在不小心误修改的时候, 让编译器及时提醒我们.
✦充分利用编译器的校验, 在实际开发中是非常有意义的.

三、接口

接口是抽象类的更进一步. 抽象类中还可以包含非抽象方法, 和字段. 而接口中包含的方法都是抽象方法, 字段只能包含静态常量。

3.1 语法规则

在刚才的打印图形的示例中, 我们的父类 Shape 并没有包含别的非抽象方法, 也可以设计成一个接口：

interface IShape {
    void draw();
}
class Cycle implements IShape {
    @Override
    public void draw() {
        System.out.println("○");
    }
}
public class Test {
    public static void main(String[] args) {
        IShape shape = new Cycle();
        shape.draw();
    }
}

✦使用 interface 定义一个接口

✦接口中的方法一定是抽象方法, 因此可以省略 abstract

✦接口中的方法一定是 public, 因此可以省略 public

✦Cycle 使用 implements 继承接口. 此时表达的含义不再是 “扩展”, 而是 “实现”

✦在调用的时候同样可以创建一个接口的引用, 对应到一个子类的实例.

✦接口不能单独被实例化.

✦接口允许多实现

扩展(extends) vs 实现(implements)
扩展指的是当前已经有一定的功能了, 进一步扩充功能.
实现指的是当前啥都没有, 需要从头构造出来

接口中只能包含抽象方法. 对于字段来说, 接口中只能包含静态常量(final static).

interface IShape {
    void draw();

    public static final int num = 10;
}

其中的 public, static, final 的关键字都可以省略. 省略后的 num 仍然表示 public 的静态常量:

interface IShape {
    void draw();

    int num = 10;
}

注意事项：

我们创建接口的时候, 接口的命名一般以大写字母 I 开头.
接口的命名一般使用 “形容词” 词性的单词.
阿里编码规范中约定, 接口中的方法和属性不要加任何修饰符号, 保持代码的简洁性，只保留方法返回值，方法参数列表，名称即可
子类实现一个接口的时候，命名以相对应的接口开头，以impl结尾。
eg：如果是IRun的子类，则建议命名为RunImpl（也不是强制要求）
如果子类实现多个父接口，不需要使用此规范命名。

提示, IDEA 中使用 ctrl + i 快速实现接口

3.2 实现多个接口（可看可不看）

有的时候我们需要让一个类同时继承自多个父类. 这件事情在有些编程语言通过 多继承 的方式来实现的.

然而 Java 中只支持单继承, 一个类只能 extends 一个父类. 但是可以同时实现多个接口, 也能达到多继承类似的效果.

现在我们通过类来表示一组动物：

class Animal {
    protected String name;

    public Animal(String name) {
        this.name = name;
    }
}

另外我们再提供一组接口, 分别表示 “会飞的”, “会跑的”, “会游泳的”

interface IFlying {
    void fly();
}
interface IRunning {
    void run();
}
interface ISwimming {
    void swim();
}

接下来我们创建几个具体的动物
猫, 是会跑的

class Cat extends Animal implements IRunning {
    public Cat(String name) {
        super(name);
    }
    @Override
    public void run() {
        System.out.println(this.name + "正在用四条腿跑");
    }
}

鱼, 是会游的

class Fish extends Animal implements ISwimming {
    public Fish(String name) {
        super(name);
    }
    @Override
    public void swim() {
        System.out.println(this.name + "正在用尾巴游泳");
    }
}

青蛙, 既能跑, 又能游(两栖动物)

class Frog extends Animal implements IRunning, ISwimming {
    public Frog(String name) {
        super(name);
    }
    @Override
    public void run() {
        System.out.println(this.name + "正在往前跳");
    }
    @Override
    public void swim() {
        System.out.println(this.name + "正在蹬腿游泳");
    }
}

还有一种神奇的动物, 水陆空三栖, 叫做 “鸭子”

class Duck extends Animal implements IRunning, ISwimming, IFlying {
    public Duck(String name) {
        super(name);
    }
    @Override
    public void fly() {
        System.out.println(this.name + "正在用翅膀飞");
    }
    @Override
    public void run() {
        System.out.println(this.name + "正在用两条腿跑");
    }
    @Override
    public void swim() {
        System.out.println(this.name + "正在漂在水上");
    }
}

上面的代码展示了 Java 面向对象编程中最常见的用法: 一个类继承一个父类, 同时实现多种接口.

继承表达的含义是 is – a 语义, 而接口表达的含义是具有 xxx 特性

猫是一种动物, 具有会跑的特性.
青蛙也是一种动物, 既能跑, 也能游泳
鸭子也是一种动物, 既能跑, 也能游, 还能飞

这样设计有什么好处呢? 时刻牢记多态的好处, 让程序猿忘记类型. 有了接口之后, 类的使用者就不必关注具体类型, 而只关注某个类是否具备某种能力.

例如, 现在实现一个方法, 叫 “散步”

public static void walk(IRunning running) {
    System.out.println("我带着伙伴去散步");
    running.run();
}

在这个 walk 方法内部, 我们并不关注到底是哪种动物, 只要参数是会跑的, 就行

Cat cat = new Cat("小猫"); 
walk(cat); 
Frog frog = new Frog("小青蛙"); 
walk(frog); 
// 执行结果
我带着伙伴去散步
小猫正在用四条腿跑
我带着伙伴去散步
小青蛙正在往前跳

甚至参数可以不是 “动物”, 只要会跑!

class Robot implements IRunning {
    private String name;

    public Robot(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        System.out.println(this.name + "正在用轮子跑");
    }
}
    Robot robot = new Robot("机器人");

    walk(robot);
// 执行结果
机器人正在用轮子跑