温故知新之：接口和抽象类有什么区别？

本文以下内容基于 JDK 8 版本。

1、接口介绍

接口是 Java 语言中的一个抽象类型，用于定义对象的公共行为。它的创建关键字是 interface，在接口的实现中可以定义方法和常量，其普通方法是不能有具体的代码实现的，而在 JDK 8 之后，接口中可以创建 static 和 default 方法了，并且这两种方法可以有默认的方法实现。

接口定义：

package basic.person;public interface IPerson {String info = "info";default void selectOne() {System.out.println("interface IPerson selectOne!");}void selectTwo();static void selectThree() {System.out.println("interface IPerson selectThree!");}
}

接口实现：

package basic.person;public class PersonImpl implements IPerson {@Overridepublic void selectTwo() {System.out.println("interface IPerson selectTwo!");System.out.println("interface IPerson info===" + info);selectOne();IPerson.selectThree();}
}

测试类：

package basic.person;import org.junit.After;
import org.junit.Before;
import org.junit.Test;public class MainTest {@Beforepublic void before(){System.out.println("junt test before init.");}//@Testpublic void test() {IPerson person =  new PersonImpl();person.selectTwo();}@Afterpublic void after(){System.out.println("junt test after init.");}
}

运行结果：

"C:\Program Files\Java\jdk1.8.0_221\bin\java.exe"************************ -junit4 basic.person.MainTest,test
junt test before init.
interface IPerson selectTwo!
interface IPerson info===info
interface IPerson selectOne!
interface IPerson selectThree!
junt test after init.Process finished with exit code 0

结论：

1. JDK 8 中接口可以定义 static 和 default 方法，并且这两种方法可以包含具体的代码实现。
2. 实现接口要使用 implements 关键字。
3. 接口不能直接实例化。
4. 接口中定义的变量默认为 public static final 类型。
5. 实现类不重写接口中的 static 和 default 方法的情况下，默认调用的是接口的方法实现。

2、抽象类介绍

抽象类和接口类似，它也是用来定义对象的公共行为的，并且它也不能直接实例化，抽象类的实现关键字为 abstract class，子类用 extends 关键字继承父类。 

抽象类：

package basic.abstractclass;public abstract class ParentPerson {int age =20;public abstract void  methodA();public void  methodB(){System.out.println("ParentPerson methodB init!");};}

实现类

package basic.abstractclass;public class Person extends ParentPerson {@Overridepublic void methodA() {System.out.println("Person methodA init;");methodB();}}

 测试类

package basic.abstractclass;import basic.person.IPerson;
import basic.person.PersonImpl;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;public class MainTest {@Beforepublic void before(){System.out.println("junt test before init.");}//@Testpublic void test() {
//        ParentPerson parentPerson = new ParentPerson();ParentPerson parentPerson = new Person();parentPerson.methodA();}@Afterpublic void after(){System.out.println("junt test after init.");}
}

测试结果：

"C:\Program Files\Java\jdk1.8.0_221\bin\java.exe" ........................
junt test before init.
Person methodA init;
ParentPerson methodB init!
junt test after init.Process finished with exit code 0

结论

1. 抽象类使用 abstract 关键字声明。
2. 抽象类中可以包含普通方法和抽象方法，抽象方法不能有具体的代码实现。
3. 抽象类需要使用 extends 关键字实现继承。
4. 抽象类不能直接实例化。
5. 抽象类中属性控制符无限制，可以定义 private 类型的属性。

3、接口和抽象类区别介绍

3.1、定义关键字不同

接口使用关键字 interface 来定义。 抽象类使用关键字 abstract 来定义。

3.2、继承或实现的关键字不同

接口使用 implements 关键字定义其具体实现。 抽象类使用 extends 关键字实现继承。

3.3、实现（子）类扩展的数量不同

接口的实现类可以实现很多接口，抽象类的子类，只能继承一个抽象类。在Java 语言中，一个类只能继承一个父类（单继承），但可以实现多个接口。

3.4、属性访问控制符不同

接口中属性的访问控制符只能是 public，接口中的属性默认是 public static final 修饰的。

 抽象类中的属性访问控制符无限制，可为任意控制符。

3.5、方法控制符不同

接口中方法的默认控制符是 public，并且不能定义为其他控制符。

抽象类中的方法控制符无限制，其中抽象方法不能使用 private 修饰。

3.6、方法实现不同

接口中普通方法不能有具体的方法实现，在 JDK 8 之后 static 和 default 方法必须有方法实现。

从上述结果可以看出：static 或 default 方法如果没有方法实现就会报错，而普通方法如果有方法实现就会报错。 ​

抽象类中普通方法可以有方法实现，抽象方法不能有方法实现。

从上述结果可以看出：抽象类中的普通方法如果没有方法实现就会报错，而抽象方法如果有方法实现则会报错。 

3.7、静态代码块使用不同

接口中不能使用静态代码块。

抽象类中可以使用静态代码块。

4、总结

1. 定义的关键字不同。
2. 子类继承或实现关键字不同。
3. 类型扩展不同：抽象类是单继承，而接口是多继承。
4. 方法访问控制符：抽象类无限制，只是抽象类中的抽象方法不能被 private 修饰；而接口有限制，接口默认的是 public 控制符。
5. 属性方法控制符：抽象类无限制，而接口有限制，接口默认的是 public 控制符。
6. 方法实现不同：抽象类中的普通方法必须有实现，抽象方法必须没有实现；而接口中普通方法不能有实现，但在 JDK 8 中的 static 和 defualt 方法必须有实现。
7. 静态代码块的使用不同：抽象类可以有静态代码块，而接口不能有。