原文链接：https://blog.csdn.net/weixin_47872288/article/details/127283356
前言
这两者经常在笔试以及面试中经常问及，甚至在项目实战中还在纠结用哪一种类型
今天就此问题详细剖析一下
以往我的文章中也有稍微提及： java框架零基础从入门到精通的学习路线（超全）
此处将其这些文章抽离公共部分，详细总结下这两概念
1. 抽象类
抽象类是类和类之间的共同特征，将这些共同特征进一步形成抽象类，由于类本身不存在，所以抽象类无法创建对象。
类到对象是实例化，对象到类是抽象
抽象方法不能被 final 修饰，因为抽象方法就是被子类实现的
采用 abstract 关键字定义的类就是抽象类，采用 abstract 关键字定义的方法就
是抽象方法
抽象的方法只需在抽象类中，提供声明，不需要实现
如果一个类中含有抽象方法，那么这个类必须定义成抽象类。抽象类中不一定有抽象方法，抽象方法必须出现在抽象类中
final和abstract不能同时同时使用，这两个关键字是对立的
抽象类的子类可以是抽象类。也可以是非抽象类
一个非抽象的类，继承抽象类，必须将抽象类中的抽象方法进行覆盖/重写/实现
抽象类无法实例化，无法创建对象，抽象类是被子类来继承的
抽象类可以有抽象类的子类
public class AbstractTest01 {
public static void main(String[] args) {
new a();//错误，不可创建对象
}
}
//定义一个抽象类
abstract class a{
}
//不是抽象类可以继承抽象类并且实例化
class b extends a{
}
//抽象子类可以继承抽象类
abstract class c extends a{
}抽象类无法实例化，但抽象类有构造函数可以供子类使用
如果抽象类定义了有参构造函数而没有无参构造函数，子类定义找不到无参构造函数会出错，抽象类无法实例化调用对象（new对象），但是有构造函数可以给子类使用
abstract class a{
}
class b extends a{
public b(){
super();
}
}抽象方法表示没有实现的方法，没有方法体的方法
没有方法体，以分号结尾
前面的修饰符列表中有abstract关键字
比如public abstract void dosome();
但是java语言中凡是没有方法体的方法都是抽象方法（×）
因为Object类中就有很多方法都没有方法体，都是以“;”结尾的，但他们都不是抽象方法
public class AbstractTest03 {
public static void main(String[] args) {
//此时不能再 new Employee 了
Person p = new Employee();
} }
abstract class Person {
private String name;
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
//此方法各个子类都可以使用
public void commonMethod1() {
System.out.println("---------commonMethod1-------");
}
//采用 abstract 定义抽象方法
public abstract void printInfo();
}
abstract class Employee extends Person {
//再次声明该方法为抽象的
public abstract void printInfo();
}
class Student extends Person {
//实现抽象的方法
public void printInfo() {
System.out.println("Student.printInfo()");
}
}2. 接口
接口是特殊的抽象类，类与类是继承extends，类与接口是实现implements，其实都是继承
接口是一种“引用数据类型”，完全抽象的，支持多继承，且一个接口可以继承多个接口，只有常量+抽象方法
所有的元素都是public修饰的，抽象方法的public abstract可以省略，常量的public static final可以省略，方法不能有方法体
定义的格式
[修饰符列表] interface 接口名{}支持多继承，且一个接口可以继承多个接口
每一个interface 都会生成一个class后缀名的文件
public class text1 {
public static void main(String[] args) {
}
}
interface a{
}
interface b extends a{
}
interface c extends a,b{
}接口中的方法是抽象，所以不能有方法体
定义抽象方法的时候可以省略修饰符public abstract
interface a{
int sum(int a,intb);//可以省略，默认系统会给你加上
void dosome();//可以执行通过
void dosome(){};//不可以执行通过，不能有方法体
}常量的定义结合final 是public static final可以省路
public class text1 {
public static void main(String[] args) {
//定义输出的时候 需要用类名加变量 也就是a.i
//而且不允许在修改常量
}
}
interface a{
public static final int i=100;
int z=1;//z也是一个常量而不是变量 不能修改
}3. 两者结合
当一个非抽象的类实现接口的话，必须将接口中所有的抽象方法全部实现（覆盖、重写）
// 特殊的抽象类，完全抽象的，叫做接口。
interface MyMath{
double PI = 3.1415926;
int sum(int a, int b);
int sub(int a, int b);
}
// 这样没问题
abstract class MyMathImpl implements MyMath {
}
//编译出错
class MyMathImpl implements MyMath {
}
//添加方法重写实现
//修正
class MyMathImpl implements MyMath {
//错误：正在尝试分配更低的访问权限; 以前为public
/*
int sum(int a, int b){
return a + b;
}
*/
// 重写/覆盖/实现 接口中的方法（通常叫做实现。）
public int sum(int a, int b){
return a + b;
}
public int sub(int a, int b){
return a - b;
}
}接口中的方法必须是public ：
如果删除执行不通过，因为接口是public，如果继承后，不写public执行后是分配更低的权限这是不行的，所以要添加public
结合多态面向接口编程
public class Test02{
public static void main(String[] args){
//错误: MyMath是抽象的; 无法实例化
//new MyMath();
// 父类型的引用指向子类型的对象
MyMath mm = new MyMathImpl();
// 调用接口里面的方法（面向接口编程。）
int result1 = mm.sum(10, 20);
System.out.println(result1);
int result2 = mm.sub(20, 10);
System.out.println(result2);
}
}接口与接口之间可以多继承，一个类也可以多个接口
interface X{
}
interface Y{
}
interface Z extends X,Y{ //接口和接口支持多继承。
}一个类可以实现多个接口
java中类和类只支持单继承。实际上单继承是为了简单而出现的，java中的接口弥补了单继承带来的缺陷
interface A{
void m1();
}
interface B{
void m2();
}
interface C{
void m3();
}
// 实现多个接口，其实就类似于多继承。
class D implements A,B,C{
// 实现A接口的m1()
public void m1(){
}
// 实现B接口中的m2()
public void m2(){
System.out.println("m2 ....");
}
// 实现接口C中的m3()
public void m3(){
}
}强转类型的时候，需要有继承关系才可
A a = new D();
//a.m2(); // 编译报错。A接口中没有m2()方法。
B b = new D();
C c = new D();
// 这个编译没问题，运行也没问题。
// 调用其他接口中的方法，你需要转型（接口转型。）
B b2 = (B)a;
b2.m2();
// 直接向下转型为D可以吗？可以
D d = (D)a;
d.m2();但如果没有继承关系不能强转
M m = new E();
// 经过测试：接口和接口之间在进行强制类型转换的时候，没有继承关系，也可以强转。
// 但是一定要注意，运行时可能会出现ClassCastException异常。
// 编译没问题，运行有问题。
K k = (K)m;
if(m instanceof K){
K k = (K)m;
interface K{
}
interface M{
}
class E implements M{
}继承和实现同时存在
extends在前 implements在后
public class Test04{
public static void main(String[] args){
// 创建对象（表面看Animal类没起作用！）
Flyable f = new Cat(); //多态。
f.fly();
}
}
// 动物类：父类
class Animal{
}
interface Flyable{
void fly();
}
// 动物类子类：猫类
// Flyable是一个接口，是一对翅膀的接口，通过接口插到猫身上，让猫变的可以飞翔。
class Cat extends Animal implements Flyable{
public void fly(){
System.out.println("飞猫起飞，翱翔太空的一只猫，很神奇，我想做一只猫！！");
}
}4. 面试总结
此处的总结偏向于两者概念的总结，将其制作成表格
抽象类是半抽象的，有构造方法，抽象类可以包含抽象方法和非抽象方法，也可以有成员变量（不仅仅是常量）
类和类之间只能单继承，一个抽象类只能继承一个类（单继承）
接口是完全抽象的，没有构造方法，接口和接口之间支持多继承，一个类可以同时实现多个接口
这在Java 8之前基本正确，但在Java 8及之后，接口可以包含默认方法和静态方法
应用场景：
关系密切：多个功能的集成部分，可用抽象类（抽象类提供简单方法）
关系不密切：不相关的类提供公共部分，可用接口