面向对象编程基础之抽象类、接口

小结

• 通过abstract定义的方法是抽象方法，它只有定义，没有实现。抽象方法定义了子类必须实现的接口规范
• 定义了抽象方法的class必须被定义为抽象类，从抽象类继承的子类必须实现抽象方法
• 如果不实现抽象方法，则该子类仍是一个抽象类
• 面向抽象编程使得调用者只关心抽象方法的定义，不关心子类的具体实现

抽象类

如果一个class定义了方法，但没有具体执行代码，这个方法就是抽象方法，抽象方法用abstract修饰。因为无法执行抽象方法，因此这个类也必须申明为抽象类（abstract class）。使用abstract修饰的类就是抽象类。我们无法实例化抽象类。

 Person p = new Person();//编译错误

抽象类的作用是只能用于被继承，因此，抽象类可以强迫子类实现其定义的抽象方法，否则会编译报错。因此，抽象方法实际上相当于定义了“规范”。

//abstract class
public class Main {
    public static void main(String[] args){
        Person p = new Student();//Person()类定义了抽象方法run()，那么在实现子类Student的时候，就必须覆写run()方法
        p.run();//输出Student.run
    }
}
abstract class Person{
    public abstract void run();
}
class Student extends Person{
    @Override
    public void run(){
        System.out.println("Student.run");
    }
}

面向对象编程

当我们定义了抽象类Person，以及具体的Student、Teacher子类的时候，我们可以通过抽象类Person类型去引用具体的子类的实例：

public static void main(String[] args){
       Person s = new Student();
       Person t = new Teacher();
    }

这种引用抽象类的好处在于，我们对其进行方法调用，并不关心Person类型变量的具体子类型：

       s.run();
       t.run();

这种尽量引用高层类型，避免引用实际子类型的方式，称之为面向对象编程。

面向抽象编程的本质就是：

• 上层代码只定义规范（例如：abstract class Person）
• 不需要子类就可以实现业务逻辑（正常编译）
• 具体的业务逻辑由不同的子类实现，调用者并不关心。

小结：

• Java的接口(interface)定义了纯抽象规范，一个类可以实现多个接口
• 接口也是数据类型，适用于向上转型和向下转型
• 接口的所有方法都是抽象方法，接口不能定义实例字段
• 接口可以定义default方法

接口

在抽象类中，抽象方法本质上是定义接口规范：即规定高层类的接口，从而保证所有子类都有相同的接口实现，这样，多态就能发挥出威力。如果一个抽象类没有字段，所有方法全部都是抽象方法：

abstract class Person{
    public abstract void run();
    public abstract String getName();
}

在Java中，使用interface可以声明一个接口：

interface Person{
    void run();
    String getname();
}

所谓interface，就是比抽象类还有抽象的纯抽象接口，因为它连字段都不能有。因为接口定义的所有方法默认都是public abstract的，所以这两个修饰符不需要写出来。当一个具体的class去实现一个interface时，需要使用implements关键字

interface Person{
    void run();
    String getName();
}
class Student implements Person{//当一个具体的class去实现一个interface时，需要使用implements关键字
    private String name;
    public Stirng (String name){
        this.name = name;
    }
    @Override
    public void run(){
        System.out.println(this.name+" run");
    }
    @Override
    public String getName(){
        return this.name;
    }
}

在Java中，一个类只能继承自另一个类，不能从多个类继承，但是，一个类可以实现多个interface，例如：

class Student implements Person,Hello{//一个类可以实现多个interface
    ...
}

Java的接口特指interface的定义，表示一个接口类型和一组方法签名，而编程接口泛指接口规范，如方法签名，数据格式，网络协议等，抽象类和接口对比如下：

接口继承

一个interface可以继承自另一个interface。interface继承自interface使用extends。它相当于扩展了接口的方法。

interface Hello{
    void hello();
}
interface Person extends Hello{//此时，Person接口继承自Hello接口
    // 因此,Person接口现在实际上有3个抽象方法签名，其中一个来自继承的Hello接口
    void run();
    String getName();
}

继承关系

合理设计interface和abstract class的继承关系，可以充分复用代码。一般来说，公共逻辑适合放在abstract class中，具体逻辑放到各个子类，而接口层次代表抽象程度。在使用的时候，实例化的对象永远只能是某个具体的子类，但总是通过接口去引用它，因为接口比抽象类更抽象

List list = new ArrayList();//用List接口引用具体子类的实例
Collection coll = list;//向上转型为Collection接口
Iterable it = coll;//向上转型为Iterable接口

default方法

实现类可以不必覆写default方法。default方法的目的是，当我们需要给接口新增一个方法时，会涉及到修改全部子类。如果新增的是default方法，那么子类就不必全部修改，只需要在需要覆写的地方去覆写新增方法。

default方法和抽象类的普通方法是有所不同的。因为interface没有字段，default方法无法访问字段，而抽象类的普通方法可以访问实例字段。

import java.util.ArrayList;

//interface
public class Main {
    public static void main(String[] args){
        //面向对象编程的特点：我们可以用抽象类Person类型去引用具体的子类的实例
        Person p = new Student("xiao");//用Person接口引用具体子类的实例
        p.run();//好处在于对其进行方法调用时，不必关心Person类型变量的具体子类型
    }
}
interface Person{//一般来说，公共逻辑放在abstract class中，具体逻辑放到各个子类
    String getName();
    default void run(){//把Person接口的run()方法改为default方法
        System.out.println(getName()+" run");//如果新增的是default方法，那么就不必在子类覆写此方法
    }
}
class Student implements Person{//当一个具体的class去实现一个interface时，需要使用implements关键字
    private String name;
    public Student(String name){
        this.name = name;
    }
    public String getName(){
        return this.name;
    }
}