接口和抽象类能够体现OOP的抽象，而接口和抽象类也是日常开发中经常用到的
抽象方法：
抽象方法就是被abstract修饰的方法，只有声明，没有实现，也就是没有方法体
public abstract void f1();
在接口中修饰符和abstract都可以不写，因为会被编译器隐式的指定
抽象类：包含抽象方法的类
1、抽象类可以有抽象方法和非抽象方法，甚至可以没有抽象方法，但是这样没有意义
public abstract class MyAbstractClass {
abstract void add();
void del(){
};
}
2、可以有构造器，但不能实例化去创建对象，你只能这样写
public static void main(String[] args) {
MyAbstractClass myAbstractClass = new MyAbstractClass() {
@Override
void add() {
System.out.println("add()");
}
};
myAbstractClass.add();
}
PS：这样本身不是实例化，而是重写方法，否则会报错。这只是创建了一个匿名内部类。
3、抽象方法的修饰符不能是private，因为需要被实现的。默认情况下是default，个人认为不是public
package com.it.nine;
public abstract class MyAbstractClass {
public MyAbstractClass() {
}
abstract void add();
}
原因如下：
上面抽象类中定义了一个默认的add()
1、在另一个包继承这个类，是无法实现add()，而把add()修饰符改成public就可以了
2、同包下去继承这个类，实现add()，修饰符也是默认，而不是public，这个类并不是抽象类，public和默认肯定不一样吧
public class Test extends MyAbstractClass{
@Override
void add() {
}
}
4、如果一个类继承抽象类，必须实现抽象类中所有的抽象方法，除非这个类也是抽象类
public abstract class Test extends MyAbstractClass{
}
接口：更加抽象的抽象类
public interface Interface1 {
public String s = "";
void f1();
void f2();
}
上面就是接口的一般形式
1、接口里都是抽象方法，默认被public修饰，无论是否显式指明
2、不能有构造器，原因基于第一条
3、成员变量默认是public static final修饰，IDE中可以看到s是斜体(static)，而且必须有初始值(final)，否则编译报错
4、如果一个类实现接口，必须实现接口中所有的方法，除非这个类也是抽象类
相同点：
接口和抽象类的修饰符都是public，无论是否声明
接口和抽象类的区别：
除了上面写的区别之外，接口和抽象类还有一些语法层面的不同：
1、抽象类可以有非抽象方法，而接口中的方法只能是public
2、抽象类的成员变量可以是各种类型，而接口中的成员变量只能是public static final类型的
3、接口中不能含有静态代码块以及静态方法，而抽象类可以有静态代码块和静态方法
4、一个类只能继承一个抽象类，而一个类却可以实现多个接口
5、抽象类可以有构造函数，接口中没有构造函数
6、抽象类可以有代码块和静态块，接口不可以
设计层面的差别：
继承是一个 "是不是"的关系，而 接口 实现则是 "有没有"的关系。如果一个类继承了某个抽象类，则子类必定是抽象类的种类，而接口实现则是
有没有、具备不具备的关系，比如鸟是否能飞（或者是否具备飞行这个特点），能飞行则可以实现这个接口，不能飞行就不实现这个接口
举个栗子：
abstract class Door {
public abstract void open();
public abstract void close();
}
或者：
interface Door {
public abstract void open();
public abstract void close();
}
现在添加报警alarm( )的功能，那么该如何实现？下面提供两种思路：
1、将这三个功能都放在抽象类里面，但是这样一来所有继承于这个抽象类的子类都具备了报警功能，但是有的门并不一定具备报警功能；
2、将这三个功能都放在接口里面，需要用到报警功能的类就需要实现这个接口中的open( )和close( )，也许这个类根本就不具备open( )和close( )这两个功能，比如火灾报警器。
从这里可以看出，Door的open() 、close()和alarm()根本就属于两个不同范畴内的行为，open()和close()属于门本身固有的行为特性，而alarm()属于延伸的附加行为。因此最好的解决办法是单独将
报警设计为一个接口，包含alarm()行为,Door设计为单独的一个抽象类，包含open和close两种行为。再设计一个报警门继承Door类和实现Alarm接口。
interface Alram {
void alarm();
}
abstract class Door {
void open();
void close();
}
class AlarmDoor extends Door implements Alarm {
void oepn() {
//....
}
void close() {
//....
}
void alarm() {
//....
}
}
接口实现多继承
java中只能实现单继承，而我们可以通过接口进行多继承（接口肯定不能implements）
public interface Interface1 {
void f1();
void f2();
}
public interface Interface2 {
void f3();
void f4();
}
public interface Interface3 {
void f5();
void f6();
}
public interface ExtendInterface extends Interface1, Interface2, Interface3{ //多继承
void extend();
}
public class MyInterface implements ExtendInterface{
@Override
public void extend() {
}
@Override
public void f1() {
}
@Override
public void f2() {
}
@Override
public void f3() {
}
@Override
public void f4() {
}
@Override
public void f5() {
}
@Override
public void f6() {
}
}
PS：当类实现这个多继承的接口ExtendInterface，需要实现之前所有接口的方法
PS：抽象类可以实现接口，可以选择是否实现接口的方法，如果不实现的话，抽象类的实现类需要实现抽象类和接口中的方法
问题：为什么抽象类有构造函数，接口中却没有？
首先抽象类虽然有构造函数，但是不能被实例化的。构造函数这里的作用，在子类被初始化的时候，必须初始化父类(抽象类)数据，而不是生成一个父类对象
，因为子类初始化有可能要用到父类的数据。
而接口中都是抽象方法，没有实现的，所有的属性都是常量(final修饰)，编译器直接生成ConstantValue属性，需要赋初值。
所以接口不需要构造函数。
jdk8+接口定义的变化：
1、可以定义static方法、默认方法
public interface MyInterface { void f(); static void f2() { System.out.println("interface f2"); } default void f3() { System.out.println("interface f3"); } }
public class Test implements MyInterface { @Override public void f() { } @Override public void f3() { MyInterface.super.f3(); } public static void main(String[] args) { new Test().f3(); MyInterface.f2(); } }
static和default修饰符为public，可以省略。static方法可以通过interface直接调用，而default方法只能上面那种方式去实现
内容参考：<Java编程思想>和https://www.cnblogs.com/dolphin0520/p/3811437.html