接口与抽象类的关系，以及使用场景

最新推荐文章于 2024-06-28 10:00:00 发布

时代在找码

最新推荐文章于 2024-06-28 10:00:00 发布

阅读量809

点赞数

分类专栏：基础文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_44750143/article/details/126992920

版权

基础专栏收录该内容

15 篇文章 0 订阅

订阅专栏

什么是抽象类和接口

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

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

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

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

public abstract class BaseActivity{
	private final String TAG =this.getClass().getSimpleName();//抽象类可以有成员
	
	void log(String msg){
		System.out.println(msg);//抽象类可以有具体方法
	}
	//abstract void initView();// 抽象类也可以没有抽象方法
}

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

接口是抽象类的延伸，它可以定义没有方法体的方法

public interface OnClickListener{
	void onClick(View v);//没有方法体
}

特点与区别：

抽象类的特点：

抽象类的初衷是“抽象”，即规定这个类“是什么”，具体的实现暂不确定，是不完整的，因此不允许直接创建实例。抽象类是由子类具有相同的一类特征抽象而来，也可以说是其基类或者父类

抽象方法必须为 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();
	}
	//其他重复的工作，比如设置标题栏、沉浸式状态栏、检测网络状态等
}

这时 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();
    }
}

定义的抽象方法访问权限修饰符可以是 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() {
        //这里加载数据
    }
}

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

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

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

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

interface OnLocationChangeListener {
    void onLocationUpdate(String locationInfo);
}

接口默认是 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);
    }
}

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

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);
    }
}

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

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

小结

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

è¿™é‡Œå†™å›¾ç‰‡æè¿°
图片来自：www.jianshu.com/p/8f0a7e22b…

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

抽象层次不同

抽象类是对类抽象，而接口是对行为的抽象
抽象类是对整个类整体进行抽象，包括属性、行为，但是接口却是对类局部行为进行抽象

跨域不同

抽象类所跨域的是具有相似特点的类，而接口却可以跨域不同的类
抽象类所体现的是一种继承关系，考虑的是子类与父类本质**“是不是”同一类的关系
而接口并不要求实现的类与接口是同一本质，它们之间只存在“有没有这个能力”**的关系

设计层次不同

抽象类是自下而上的设计，在子类中重复出现的工作，抽象到抽象类中
接口是自上而下，定义行为和规范

如何选择

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

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

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

抽象与多态

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

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

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

面向接口编程

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

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

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

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

通过构造函数传递依赖对象

比如在构造函数中的需要传递的参数是抽象类或接口的方式实现

通过 setter 方法传递依赖对象

即在我们设置的 setXXX 方法中的参数为抽象类或接口，来实现传递依赖对象

接口声明实现依赖对象，也叫接口注入

即在函数声明中参数为抽象类或接口，来实现传递依赖对象，从而达到直接使用依赖对象的目的。
可以看到，“面向接口编程”说的“接口”也包括抽象类，其实说的是基类，越简单越好。

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

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

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

接口实现
继承父类重写方法
同一类中进行方法重载

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

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

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

以上面的代码为例：

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);
            }
        }
    }
}

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

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

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

继承和组合

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

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

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

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

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

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

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

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

总结

1> 接口
1.1 声明关键字 interface
1.2 子类使用implements 关键字来实现接口，它需要实现接口中提供的所有的方法
1.3 接口默认修饰符是public 并且只允许定义为private 以及protected
1.4 一个类允许实现多个接口
1.5 接口的字段默认是static 和final的
1.6 接口是一种自上而下的约束，定义行为和规范
1.7 接口中不允许有构造器，可以定义没有方法体的方法，所有可以理解为是对行为的抽象
1.8 对接口进行扩展，子类必须实现父类新增的方法

2>抽象类
2.1 声明关键字abstract
2.2 子类使用extends关键字来继承抽象类，如果子类不是抽象类的化，它需要提供抽象类中所有方法的实现
2.3：抽象类中可以使用所有的修饰符
2.4：一个类只允许继承一个抽象类
2.5 抽象类中的字段声明可以是任意的
2.6 抽象类是一种自下而上的设计，在子类中重复出现的工作，抽象到抽象类中
2.7 抽象类可以有构造器，可以有方法体，属性，行为所以抽象类是对类的抽象
2.8 对抽象类进行添加新的方法，可以提供默认的实现，因此可以不修改子类的现有代码