关于抽象类和接口（详解）

一、抽象类

有些方法是抽象的，没有实际工作的方法, 我们可以把它设计成一个抽象方法，比如draw（画画），不能实例化对象。包含抽象方法的类我们称为 抽象类(abstract class)。

1.语法规则

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

（1）在 draw 方法前加上 abstract 关键字, 表示这是一个抽象方法. 同时抽象方法没有方法体(没有 { }, 不能执行具体代码)。
（2）对于包含抽象方法的类, 必须加上 abstract 关键字表示这是一个抽象类。

2.注意事项

1. 抽象类不能直接实例化。

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

2. 抽象方法不能是 private 的。

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

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

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 

3.抽象类的作用

（1）抽象类存在的最大意义就是为了被继承。
（2）抽象类本身不能被实例化, 要想使用, 只能创建该抽象类的子类. 然后让子类重写抽象类中的抽象方法。
（3）使用抽象类的场景就如上面的代码, 实际工作不应该由父类完成, 而应由子类完成. 那么此时如果不小心误用成父类了,
（4）使用普通类编译器是不会报错的. 但是父类是抽象类就会在实例化的时候提示错误, 让我们尽早发现问题.
（5）很多语法存在的意义都是为了 “预防出错”, 例如我们曾经用过的 final 也是类似. 创建的变量用户不去修改, 不就相当于常量嘛? 但是加上 final 能够在不小心误修改的时候, 让编译器及时提醒我们.充分利用编译器的校验, 在实际开发中是非常有意义的.

二、接口

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

1.语法规则

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 Rect(); 
        shape.draw(); 
    } 
}

（1）使用 interface 定义一个接口
（2）接口中的方法一定是抽象方法, 因此可以省略 abstract
（3）接口中的方法一定是 public, 因此可以省略 public
（4）Cycle 使用 implements 继承接口. 此时表达的含义不再是 “扩展”, 而是 “实现”
（5）在调用的时候同样可以创建一个接口的引用, 对应到一个子类的实例.
（6）接口不能单独被实例化
接口中只能包含抽象方法. 对于字段来说, 接口中只能包含静态常量(final static).

interface IShape { 
    void draw(); 
    public static final int num = 10; 
} 

2.实现多个接口

（1）有的时候我们需要让一个类同时继承自多个父类. 这件事情在有些编程语言通过 多继承 的方式来实现的.
（2）然而 Java 中只支持单继承, 一个类只能 extends 一个父类. 但是可以同时实现多个接口, 也能达到多继承类似的效果.
（3）现在我们通过类来表示一组动物

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 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 + "正在蹬腿游泳"); 
    } 
} 

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