抽象类abstract与接口interface区别代码实战演示——观止

请自己阅读以下代码，每个修饰符我都仔细斟酌写上去的，都很有考究。

笔者为了写好这篇文章，查阅了很多相关资料，以求总结地准确和全面，花了很多工夫，希望大家珍惜。

把这些代码读懂了，抽象类与接口的区别你就过关了。

你能通过这些代码很直观地总结出所有抽象类和接口的性质及区别，面试这个知识点基本逃不过下面的代码。

为什么我只放代码，不直接写出结论让大家直接观阅呢？

因为你直接看结论，记不住！！！过两天你就忘记了。这东西本来没可遵循的规律，记忆点还多，如果你不懂底层源码那忘记更快。

你可以对着我亲自实验的代码，自己总结规律。

最好的办法，是把这些代码拿走，自己动手实验，再总结，这样印象更深刻。

建议收藏本文以便时不时实践、复习一下。

等你熟悉到一定程度，只需浏览、对比一下代码就能迅速想起来所有的区别点。

以下所有测试基于jdk1.8，且所有类在IDEA里都不报错。

抽象类： 

//抽象类不能用final、private、static修饰
public abstract  class TestAbstract {
    //可以有有参和无参构造器,但必须有方法体
    public TestAbstract() {

    }
    public TestAbstract(String s,int d){
        this.s = s;
        this.d = d;
    }
    public String s;//成员属性不可定义为abstract
    private int d;//可为private
    private  static int ds;//静态属性可不初始化
    private final static int q = 0;//final修饰必须初始化
    //可以有静态块
    static {
//        public int d;//不能为public
//        private String as;//不能为private
//        protected int b;//不能为protected
//        static int d = 0;//不能为static
        int a;//可不初始化
    }

    //private修饰时只能带方法体，不能转为抽象方法，即abstract不能与private、static、final共存
    private String abs() {
        return null;
    }
//    public String abp() ;//public修饰时要么抽象方法要么有方法体

    //    private abstract String pa();//不能是私有抽象方法
    //抽象方法必无方法体，且可没有抽象方法，abstract不能与private、default、static、final共存
    protected abstract  String pa();
    //static 不能与abstract、default共存,且必带方法体
    private static String pas() {
        return null;
    }
    //可以final修饰
    private final static String psv() {
        return null;
    }
//不能有default修饰的方法
    /*default String hu() {
        return null;
    }*/

    //final不能与default共存
    private final int f() {
        return 0;
    }
    //内部抽象类可以用static、private修饰，但是不能用final修饰,抽象类可实现接口，不能继承抽象类TestAbstract
    private abstract  static class innerAbs implements testInterface {

    }
    //抽象类内部可定义接口,接口可继承接口(不可实现implements),不可继承抽象类TestAbstract
    private static interface innerAbsI extends testInterface {

    }
}

接口：

//接口不能使用private、static、final修饰
public interface  testInterface {
    //    public testInterface();//无参构造器不被允许
//    public testInterface(String ww);//有参构造器不被允许
    int dig=0;
    public final static String s = null;//不可为private、protected且成员变量必须初始化,但可以是public和缺省符
    static final String  sw=null;
    final String ww = null;//final可有可无，但变量必须赋值
    //    private static String ss = new String();//不能为private
    //不允许静态块
    /*static {
        String s = "";
    }*/

    //public abstract  int a ;//不允许为抽象属性
    abstract String asb();//可有抽象方法,且不能有方法体,abstract不能与private、protected、default、static、final共存

    //静态方法必须有方法体,static不能与default、private、protected、abstract、final共存
     static String qq() {
        return null;
    }

    //    public String d(){};//无static就不能有方法体
    int dd();

    //default修饰必须要有方法体，default不可与abstract、static、final共存
    default int d() {
        return 0;
    }
//    private String df();//方法不能是private和protected的
//    public static final  t(){};//方法中final不能与static共存
//接口内部抽象类不能被private、final修饰，不能继承抽象类TestAbstract
    abstract static class innerIAbs implements testInterface {

    }
//内部接口不能被private、final修饰,接口可继承接口,但不可实现implements接口，不能继承抽象类,
     static  interface innerI extends testInterface {

    }
}

外部测试抽象类：

//如果TestAbstract类的构造是私有的，抽象类则不能继承,此处可继承抽象类（也可继承实体类）、可实现接口
public abstract class testAbs extends TestAbstract implements testInterface{
    public static void main(String[] args) {

    }
}

外部测试接口：

//外部接口还是只能继承接口不能实现，不能继承抽象类和实体类
public interface testInt extends testInterface {
    public static void main(String[] args) {

    }
}

普通测试类实现接口：

public class testI implements testInterface {
    @Override
    public String asb() {
        return null;
    }

    @Override
    public int dd() {
        return 0;
    }
}

普通测试类继承抽象类：

public class testA extends TestAbstract{
    @Override
    protected String pa() {
        return null;
    }
}

还是挑重点总结一下吧：

（1）实现接口类必须实现（抽象类除外，如上述的抽象类testAbs）接口中所有的不带方法体的方法，即static和default修饰的方法除外；

（2）继承抽象类必须重写（抽象类除外，如上述的抽象类testAbs）他的所有抽象方法；

（3）接口定义的是对象的行为（即功能作用，能做什么），抽象类定义的是对象的本体组成（即是什么）；

（4）接口要实现，抽象类要继承，一个类可以实现多个接口，但只能继承一个抽象类；

（5）接口可以继承接口，抽象类可以实现接口还可同时继承抽象类，抽象类也可以继承具体类，但接口不能。

（6）抽象类和接口都可以有静态的main方法；

（7）接口和抽象类中的抽象方法都不能有方法体；

（8）接口中可有default修饰的方法，抽象类不可以；

（9）接口和抽象类都不能使用private、static、final修饰；

（10）接口不能有有参和无参构造器，而抽象类都可以有；

（11）接口的成员变量不可以是private的，但抽象类可以；

（12）抽象类可由静态块，接口不能有；

（13）抽象类和接口都可以有静态方法，且都必须带方法体；

（14）抽象类中非抽象方法必带方法体，接口不必；

（15）接口和抽象类都可有非static、final修饰的普通成员变量；

参考（下面两篇文章中总结的有错误，以我代码试验为准）：

https://blog.csdn.net/m0_38105216/article/details/85067156

https://blog.csdn.net/qq_44543508/article/details/102609910