Java基础相关（二、抽象类、接口）

文章出自：安卓进阶学习指南

主要贡献者：

• Milo
• Struggle
• shixinzhang

读完本文你将了解：

• 背景介绍
• 什么是抽象类和接口
• 特点与区别
• 如何选择
• 抽象与多态
• 总结
• Thanks

背景介绍

大家好，这篇文章是 《安卓进阶技能树计划》 的第一部分 《Java 基础系列》 的第一篇。

距离上一篇预告 《Java 基础夯实系列上线预告》 过去了很久，之所以这么慢，是因为我们做这个活动，除了要保证知识点的全面、完整，还想要让每一篇文章都有自己的思考，尽可能的将知识点与实践结合，努力让读者读了有所收获。每位小伙伴都有工作在身，每个知识点都需要经过思考、学习、写作、提交、审核、修改、编辑、发布等多个过程，所以整体下来时间就会慢一些，这里先向各位道歉。

《Java 基础系列》初步整理大概有 12 篇，主要内容为。：

1. 抽象类和接口
2. 内部类
3. 修饰符
4. 装箱拆箱
5. 注解
6. 反射
7. 泛型
8. 异常
9. 集合
10. IO
11. 字符串
12. 其他

第一篇我们来聊聊抽象类和接口。

“抽象类和接口”听起来是非常普遍的东西，有些朋友会觉得：这个太基础了吧，有啥好说的，你又来糊弄我。

事实上我在面试中不仅一次被问到相关的问题：

• 抽象类和接口之间的区别？
• 什么时候创建抽象类？什么时候创建接口？
• 设计框架时该如何选择？

我比较喜欢这样的问题，答案可深可浅，体现了我们对日常工作的思考。

我们什么时候会创建一个抽象类？什么时候会创建一个接口呢？当转换一下思维，不仅仅为了完成功能，而是要保证整个项目架构的稳定灵活可扩展性，你会如何选择呢？

这篇文章我们努力回答这些问题，也希望你可以说出你的答案。

什么是抽象类和接口

抽象方法 即使用 abstract 关键字修饰，仅有声明没有方法体的方法。

public abstract void f();    //没有内容

• 1

抽象类 即包含抽象方法的类。

如果一个类包含一个或者多个抽象方法，该类必须被限定为抽象的。抽象类可以不包含抽象方法。

public abstract class BaseActivity {
    private final String TAG = this.getClass().getSimpleName(); //抽象类可以有成员

    void log(String msg){   //抽象类可以有具体方法
        System.out.println(msg);
    }

//    abstract void initView();     //抽象类也可以没有抽象方法
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9

接口 是抽象类的一种特殊形式，使用 interface 修饰。

public interface OnClickListener {
    void onClick(View v);
}

• 1
• 2
• 3

特点与区别

抽象类的特点

抽象类的初衷是“抽象”，即规定这个类“是什么”，具体的实现暂不确定，是不完整的，因此不允许直接创建实例。

• 抽象类是由子类具有相同的一类特征抽象而来，也可以说是其基类或者父类
• 抽象方法必须为 public 或者 protected（因为如果为 private，则不能被子类继承，子类便无法实现该方法），缺省情况下默认为 public
• 抽象类不能用来创建对象
• 抽象方法必须由子类来实现
• 如果一个类继承于一个抽象类，则子类必须实现父类的抽象方法，如果子类没有实现父类的抽象方法，则必须将子类也定义为抽象类
• 抽象类还是很有用的重构工具，因为它们使得我们可以很容易地将公共方法沿着继承层次结构向上移动

接口的特点

Java 为了保证数据安全性是不能多继承的，也就是一个类只有一个父类。

但是接口不同，一个类可以同时实现多个接口，不管这些接口之间有没有关系，所以接口弥补了抽象类不能多继承的缺陷。

接口是抽象类的延伸，它可以定义没有方法体的方法，要求实现者去实现。

• 接口的所有方法访问权限自动被声明为 public
• 接口中可以定义“成员变量”，会自动变为 public static final 修饰的静态常量
  
  • 可以通过类命名直接访问：ImplementClass.name
  • 不推荐使用接口创建常量类
• 实现接口的非抽象类必须实现接口中所有方法，抽象类可以不用全部实现
• 接口不能创建对象，但可以申明一个接口变量，方便调用
• 完全解耦，可以编写可复用性更好的代码

栗子

前面说了太多，我们直接上代码。

假设我们新开始一个项目，需要写大量的 Activity，这些 Activity 会有一些通用的属性和方法，于是我们会创建一个基类，把这些通用的方法放进去：

public class BaseActivity extends Activity {
    private final String TAG = this.getClass().getSimpleName(); 

    void toast(String msg) {   
        Toast.makeText(this, msg, Toast.LENGTH_SHORT).show();
    }  
    //其他重复的工作，比如设置标题栏、沉浸式状态栏、检测网络状态等等
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8

这时 BaseActivity 是一个基类，它的作用就是：封装重复的内容。

写着写着，我们发现有的同事代码写的太烂了，一个方法里几百行代码，看着太痛苦。于是我们就本着“职责分离”的原则，在 BaseActivity 里创建了一些抽象方法，要求子类必须实现：

public abstract class BaseActivity extends Activity {
    private final String TAG = this.getClass().getSimpleName();

    @Override
    protected void onCreate(final Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(getContentViewLayoutId());

        initView(); //这里初始化布局
        loadData(); //这里加载数据
    }

    /**
     * 需要子类实现的方法
     * @return
     */
    protected abstract int getContentViewLayoutId();
    protected abstract void initView();
    protected abstract void loadData();

    void toast(String msg) {
        Toast.makeText(this, msg, Toast.LENGTH_SHORT).show();
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24

定义的抽象方法访问权限修饰符可以是 public protected 和 default，但不能是 private，因为这样子类就无法实现了。

这时 BaseActivity 因为有了抽象方法，变成了一个抽象类。它的作用就是：定义规范，强制子类符合标准；如果有调用抽象方法，也会制定执行顺序的规则。

继承 BaseActivity 的类只要实现这些方法，同时为父类提供需要的内容，就可以和父类一样保证代码的整洁性。

public class MainActivity extends BaseActivity{

    private TextView mTitleTv;

    @Override
    protected int getContentViewLayoutId() {
        return R.layout.activity_main;
    }

    @Override
    void initView() {
        mTitleTv = (TextView) findViewById(R.id.main_title_tv);
        mTitleTv.setOnClickListener(this);
    }

    @Override
    protected void loadData() {
        //这里加载数据
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20

以后如果发现有某些功能在不同 Activity 中重复出现的次数比较多，就可以把这个功能的实现提到 BaseActivity 中。但是注意不要轻易添加抽象方法，因为这会影响到之前的子类。

项目写着写着，发现很多页面都有根据定位信息改变而重新请求数据的情况，为了方便管理，再把这样的代码放到 BaseActivity？ 也可以，但是这样一来，那些不需要定位相关的代码不也被“污染”了么，而且冗余逻辑太多 BaseActivity 不也成了大杂烩了么。

我们想要把位置相关的放到另一个类，但是 Java 只有单继承，这时就可以使用接口了。

我们创建一个接口表示对地理位置的监听：

interface OnLocationChangeListener {
    void onLocationUpdate(String locationInfo);
}

• 1
• 2
• 3

接口默认是 public,不能使用其他修饰符。

然后在一个位置观察者里持有这个接口的引用：

public class LocationObserver {

    List<OnLocationChangeListener> mListeners;

    public LocationObserver setListeners(final List<OnLocationChangeListener> listeners) {
        mListeners = listeners;
        return this;
    }

    public List<OnLocationChangeListener> getListeners() {
        return mListeners;
    }

    public void notify(String locationInfo) {
        if (mListeners != null) {
            for (OnLocationChangeListener listener : mListeners) {
                listener.onLocationUpdate(locationInfo);
            }
        }
    }

    interface OnLocationChangeListener {
        void onLocationUpdate(String locationInfo);
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26

这样我们在需要定位的页面里实现这个接口：

public class MainActivity extends BaseActivity implements View.OnClickListener,
        LocationObserver.OnLocationChangeListener {

    private TextView mTitleTv;

    @Override
    protected int getContentViewLayoutId() {
        return R.layout.activity_main;
    }

    @Override
    public void onClick(final View v) {
        int id = v.getId();
        if (id == R.id.main_title_tv) {
            toast("你点击了 title");
        }
    }

    @Override
    void initView() {
        mTitleTv = (TextView) findViewById(R.id.main_title_tv);
        mTitleTv.setOnClickListener(this);
    }

    @Override
    protected void loadData() {
        //这里加载数据
    }

    @Override
    public void onLocationUpdate(final String locationInfo) {
        mTitleTv.setText("现在位置是：" + locationInfo);
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34

这样 MainActivity 就具有了监听位置改变的能力。

如果 MainActivity 中需要添加其他功能，可以再创建对应的接口，然后予以实现。

小结

通过上面的代码例子，我们可以很清晰地了解下面这张图总结的内容。

图片来自：http://www.jianshu.com/p/8f0a7e22bb8c

我们可以了解到抽象类和接口的这些不同：

• 抽象层次不同
  
  • 抽象类是对类抽象，而接口是对行为的抽象
  • 抽象类是对整个类整体进行抽象，包括属性、行为，但是接口却是对类局部行为进行抽象
• 跨域不同
  
  • 抽象类所跨域的是具有相似特点的类，而接口却可以跨域不同的类
  • 抽象类所体现的是一种继承关系，考虑的是子类与父类本质“是不是”同一类的关系
  • 而接口并不要求实现的类与接口是同一本质，它们之间只存在“有没有这个能力”的关系
• 设计层次不同
  
  • 抽象类是自下而上的设计，在子类中重复出现的工作，抽象到抽象类中
  • 接口是自上而下，定义行为和规范

如何选择

现在我们知道了，抽象类定义了“是什么”，可以有非抽象的属性和方法；接口是更纯的抽象类，在 Java 中可以实现多个接口，因此接口表示“具有什么能力”。

在进行选择时，可以参考以下几点：

• 若使用接口，我们可以同时获得抽象类以及接口的好处
• 所以假如想创建的基类没有任何方法定义或者成员变量，那么无论如何都愿意使用接口，而不要选择抽象类
• 如果事先知道某种东西会成为基础类，那么第一个选择就是把它变成一个接口
• 只有在必须使用方法定义或者成员变量的时候，才应考虑采用抽象类

此外使用接口最重要的一个原因：实现接口可以使一个类向上转型至多个基础类。

比如 Serializable 和 Cloneable 这样常见的接口，一个类实现后就表示有这些能力，它可以被当做 Serializable 和 Cloneable 进行处理。

推荐接口和抽象类同时使用，这样既保证了数据的安全性又可以实现多继承。

抽象与多态

俗话说：“做事留一线，日后好相见”。

程序开发也一样，它是一个不断递增或者累积的过程，不可能一次做到完美，所以我们要尽可能地给后面修改留有余地，而这就需要我们使用传说中“面向对象的三个特征” — 继承、封装、多态。

不管使用抽象类还是接口，归根接地还是尽可能地职责分离，把业务抽象，也就是“面向接口编程”。

面向接口编程

日常生活里与人约定时，一般不要说得太具体。就好比别人问我们什么时候有空，回一句“大约在冬季” 一定比 “这周六中午” 灵活一点，谁知道这周六会不会突然有什么变故。

我们在写代码时追求的是“以不变应万变”，在需求变更时，尽可能少地修改代码就可以实现。

而这，就需要模块之间依赖时，最好都只依赖对方给的抽象接口，而不是具体实现。

在设计模式里这就是“依赖倒置原则”，依赖倒置有三种方式来实现：

1. 通过构造函数传递依赖对象
   
   • 比如在构造函数中的需要传递的参数是抽象类或接口的方式实现
2. 通过 setter 方法传递依赖对象
   
   • 即在我们设置的 setXXX 方法中的参数为抽象类或接口，来实现传递依赖对象
3. 接口声明实现依赖对象，也叫接口注入
   
   • 即在函数声明中参数为抽象类或接口，来实现传递依赖对象，从而达到直接使用依赖对象的目的。

可以看到，“面向接口编程”说的“接口”也包括抽象类，其实说的是基类，越简单越好。

多态

多态指的是编译期只知道是个人，具体是什么样的人需要在运行时能确定，同样的参数有可能会有不同的实现。

通过抽象建立规范，在运行时替换成具体的对象，保证系统的扩展性、灵活性。

实现多态主要有以下三种方式:

1. 接口实现

2. 继承父类重写方法

3. 同一类中进行方法重载

不论哪种实现方式，调用者持有的都是基类，不同的实现在他看来都是基类，使用时也当基类用。

这就是“向上转型”，即：子类在被调用过程中由继承关系的下方转变成上面的角色。

向上转型是能力减少的过程，编译器可以帮我们实现；但 “向下转型”是能力变强的过程，需要进行强转。

以上面的代码为例：

public class LocationObserver {

    List<OnLocationChangeListener> mListeners;

    public LocationObserver setListeners(final List<OnLocationChangeListener> listeners) {
        mListeners = listeners;
        return this;
    }

    public List<OnLocationChangeListener> getListeners() {
        return mListeners;
    }

    public void notify(String locationInfo) {
        if (mListeners != null) {
            for (OnLocationChangeListener listener : mListeners) {
                listener.onLocationUpdate(locationInfo);
            }
        }
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21

LocationObserver 持有的是 OnLocationChangeListener 的引用，不管运行时传入的是 MainActivity 还是其他 Activity，只要实现了这个接口，就可以被调用实现的方法。

在编译期就知道要调用的是哪个方法，称为“前期绑定”（又称“静态绑定”），由编译器和连接程序实现。

在运行期调用正确的方法，这个过程称为“动态绑定”，要实现动态绑定，就要有一种机制在运行期时可以根据对象的类型调用恰当的方法。这种机制是由虚拟机实现的， invokevirtual 指令会把常量池中的类方法符号引用解析到不同的引用上，这个过程叫做“动态分派”，具体的实现过程我们暂不讨论。

继承和组合

尽管继承在学习 OOP 的过程中得到了大量的强调，但并不意味着应该尽可能地到处使用它。

相反，使用它时要特别慎重，因为继承一个类，意味着你需要接受他的一切，不管贫穷富贵生老病死，你都得接受他，你能做到吗？

一般人都无法做到白头偕老，所以只有在清楚知道需要继承所有方法的前提下，才可考虑它。

有一种取代继承的方式是 “组合”。

组合就是通过持有一个类的引用来拥有他的一切，而不是继承，在需要调用他的方法时传入引用，然后调用，否则就清除引用。

组合比继承灵活在于关系更松一些，继承表示的是“is-a” 关系，比较强；而组合则是 “has-a” 关系。

为判断自己到底应该选用合成还是继承，一个最简单的办法就是考虑是否需要从新类向上转型回基础类。

假如的确需要向上转，就使用继承；但如果不需要上溯造型，就应提醒自己防止继承的滥用。

总结

这篇文章的目的是帮助读者了解、掌握抽象类和接口的特点和不同的使用场景，后面写着写着又多唠叨了几句，希望对你有帮助。

这个系列的目的是帮助大家系统、完整的打好基础、逐渐深入学习，如果你对这些已经很熟了，请不要吝啬你的评价，多多指出问题，我们一起做的更好！

文章同步发送于微信公众号：安卓进化论，欢迎关注，第一时间获取新文章。

Thanks

• 《Java 编程思想》
• http://www.jianshu.com/p/8f0a7e22bb8c