如果你对接口和抽象类的使用场景比较模糊，这篇文章或许会对你有所帮助。
首先看抽象类，它介于普通类和接口之间，尽管在构建某些未实现方法的类时，很多时候 往往会去创建接口，但抽象类仍然很重要，因为你不可能总是使用纯接口。
一. 抽象类
“在面向对象的概念中，我们知道所有的对象都是通过类来描绘的，但是反过来却不是这样。并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。抽象类往往用来表征我们在对问题领域进行分析、设计中得出的抽象概念，是对一系列看上去不同，但是本质上相同的具体概念的抽象。比如：如果我们进行一个图形编辑软件的开发，就会发现问题领域存在着圆、三角形这样一些具体概念，它们是不同的，但是它们又都属于形状这样一个概念，形状这个概念在问题领域是不存在的，它就是一个抽象概念。正是因为抽象的概念在问题领域没有对应的具体概念，所以用以表征抽象概念的抽象类是不能够实例化的。”
抽象类的特征：
- 如果从一个抽象类继承，并想创建该类的对象，那么就必须全部实现此抽象类的所有抽象方法。如果不这样做（可以不做），那么继承后得到的便也是抽象类，且编译器会强制我们用abstract来修饰此类。
- 我们也可以创建一个没有任何抽象方法的抽象类，用来阻止产生这个类的任何对象。
- 抽象类可以有方法体，也就是实现的方法，
来个例子：
具体类：低级程序猿 高级程序猿
共性：姓名 工号 薪水
差异： 做事 奖金
abstract class Programmer{
private String name;
private String id;
private int salary;
public Programmer(){}
public Programmer(String name,String id,int salary){
this.name=name;
this.id=id;
this.salary=salary;
}
public void setname(String name){
this.name=name;
}
public String getname(){
return name;
}
public void setid(String id){
this.id=id;
}
public String getid(){
return id;
}
public void setsalary(int salary){
this.salary=salary;
}
public int getsalary(){
return salary;
}
public abstract void work();
}
class BasicProgrammer extends Programmer{
public BasicProgrammer(){}
public BasicProgrammer(String name,String id,int salary){
super(name,id,salary);
}
public void work(){
System.out.println("写曾删改查");
}
}
class GoodProgrammer extends Programmer{
private int money;
public Goodprogrammer() {}
public GoodProgrammer(String name,String id,int salary,int money){
super(name,id,salary);
this.money=money;
}
public void setmoney(int money){
this.money=money;
}
public int getmoney(){
return money;
}
public void work(){
System.out.println("写架构");
}
}
class AbstractTest{
public static void main(String[] args){
Programmer bp=new BasicProgrammer();
bp.setname("Basicprogrammer");
bp.setid("00531");
bp.setsalary(8000);
System.out.println(bp.getname()+"----"+bp.getid()+"----"+bp.getsalary());
//这里不能向上转型，向上转型后不能调用子类特有的方法，多态的弊端
GoodProgrammer gp=new GoodProgrammer();
gp.setname("Goodprogrammer");
gp.setid("00111");
gp.setsalary(20000);
gp.setmoney(10000);
System.out.println(gp.getname()+"----"+gp.getid()+"----"+gp.getsalary()+"----"+gp.getmoney());
}
}
结果：
Basicprogrammer—-00531—-8000
Goodprogrammer—-00111—-20000—-10000
再加一句--------在代码重构方面，抽象类很有用，因为它可以使我们很容易的将公共方法沿着继承层次结构向上移动
二. 接口
Java接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。
这是之前对接口的描述，但Java8中添加了接口的新特性--------接口的默认方法和静态方法
Java 8使用两个新概念扩展了接口的含义：默认方法和静态方法。默认方法使得接口有点类似traits，不过要实现的目标不一样。默认方法使得开发者可以在 不破坏二进制兼容性的前提下，往现存接口中添加新的方法，即不强制那些实现了该接口的类也同时实现这个新加的方法。
默认方法和抽象方法之间的区别在于抽象方法需要实现，而默认方法不需要。接口提供的默认方法会被接口的实现类继承或者覆写，例子代码如下：
private interface Defaulable {
// Interfaces now allow default methods, the implementer may or
// may not implement (override) them.
default String notRequired() {
return "Default implementation";
}
}
private static class DefaultableImpl implements Defaulable {
}
private static class OverridableImpl implements Defaulable {
@Override
public String notRequired() {
return "Overridden implementation";
}
}
Defaulable接口使用关键字default定义了一个默认方法notRequired()。DefaultableImpl类实现了这个接口，同时默认继承了这个接口中的默认方法；OverridableImpl类也实现了这个接口，但覆写了该接口的默认方法，并提供了一个不同的实现。
Java 8带来的另一个有趣的特性是在接口中可以定义静态方法，例子代码如下：
private interface DefaulableFactory {
// Interfaces now allow static methods
static Defaulable create( Supplier< Defaulable > supplier ) {
return supplier.get();
}
}
下面的代码片段整合了默认方法和静态方法的使用场景：
public static void main( String[] args ) {
Defaulable defaulable = DefaulableFactory.create( DefaultableImpl::new );
System.out.println( defaulable.notRequired() );
defaulable = DefaulableFactory.create( OverridableImpl::new);
System.out.println( defaulable.notRequired());
}
这段代码的输出结果如下：
Default implementation
Overridden implementation
由于JVM上的默认方法的实现在字节码层面提供了支持，因此效率非常高。默认方法允许在不打破现有继承体系的基础上改进接口。该特性在官方库中的应用是：给java.util.Collection接口添加新方法，如stream()、parallelStream()、forEach()和removeIf()等等。
尽管默认方法有这么多好处，但在实际开发中应该谨慎使用：在复杂的继承体系中，默认方法可能引起歧义和编译错误。如果你想了解更多细节，可以参考官方文档。
接口的特征：
接口中的方法可以有参数列表和返回类型，但不能有任何方法体。
接口中可以包含字段，但是会被隐式的声明为 static 和 final 。
接口中的字段只是被存储在该接口的静态存储区域内，而不属于该接口。
接口中的方法可以被声明为 public 或不声明，但结果都会按照 public 类型处理。
当实现一个接口时，需要将被定义的方法声明为 public 类型的，否则为默认访问类型， Java 编译器不允许这种情况。
如果没有实现接口中所有方法，那么创建的仍然是一个接口。
扩展一个接口来生成新的接口应使用关键字 extends ，实现一个接口使用 implements 。
例子：
定义接口AreaInterface，其中有静态常量pai和求面积的抽象方法area（）。类Circle和类Triangle 实现了AreaInterface接口，即为接口中的抽象方法area（）编写了满足各自要求的方法体，分别求圆形和三角形的面积。
public interface AreaInterface{
public double pai =Math.PI;
public double area();
}
public class Circle implement AreaInterface{
private double r;
public Circle(double x){
r=x;
}
public double area() {
return pai*r*r;
}
public String toString(){
return "圆：r="+r+"\tarea="+area();
}
}
public class Triangle implement AreaInterface{
private double d;
private double h;
public Triangle(double d,double h){
this.d=d;
this.h=h;
}
public double area() {
return d*h/2;
}
public String toString(){
return "三角形：d="+d+";h="+h+"\tarea="+area();
}
public static void main(String[] args) {
System.out.println(new Triangle(12, 5).toString());
System.out.println(new Circle(5).toString());
}
}
结果：
三角形：d=12.0; h=5.0 area=30.0
圆：r=5.0 area=78.53981633974483
三. 接口与抽象类的区别
1.语法层面上的区别
1）抽象类可以提供成员方法的实现细节，而接口中只能存在 public abstract (可省) 方法；
2）抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final (可省) 类型的；
3）接口中不能含有静态代码块以及静态方法，而抽象类可以有静态代码块和静态方法；
4）一个类只能继承一个抽象类，而一个类却可以实现多个接口。
2.设计层面上的区别
1） 抽象类是对一种事物的抽象，即对类抽象，而接口是对行为的抽象。抽象类是对整个类整体进行抽象，包括属性、行为，但是接口却是对类局部（行为）进行抽象。举个简单的例子，飞机和鸟是不同类的事物，但是它们都有一个共性，就是都会飞。那么在设计的时候，可以将飞机设计为一个类 Airplane，将鸟设计为一个类 Bird，但是不能将飞行 这个特性也设计为类，因此它只是一个行为特性，并不是对一类事物的抽象描述。此时可以将 飞行 设计为一个接口Fly，包含方法fly()，然后Airplane和Bird分别根据自己的需要实现Fly这个接口。然后至于有不同种类的飞机，比如战斗机、民用飞机等直接继承Airplane即可，对于鸟也是类似的，不同种类的鸟直接继承Bird类即可。从这里可以看出，继承是一个 “是不是”的关系，而 接口 实现则是 “有没有”的关系。如果一个类继承了某个抽象类，则子类必定是抽象类的种类，而接口实现则是有没有、具备不具备的关系，比如鸟是否能飞（或者是否具备飞行这个特点），能飞行则可以实现这个接口，不能飞行就不实现这个接口。
2） 设计层面不同，抽象类作为很多子类的父类，它是一种模板式设计。而接口是一种行为规范(契约)，它可以跨越不同的类，是一种辐射式设计。什么是模板式设计？最简单例子，大家都用过ppt里面的模板，如果用模板A设计了ppt B和ppt C，ppt B和ppt C公共的部分就是模板A了，如果它们的公共部分需要改动，则只需要改动模板A就可以了，不需要重新对ppt B和ppt C进行改动。而辐射式设计，比如某个电梯都装了某种报警器，一旦要更新报警器，就必须全部更新。也就是说 对于抽象类，如果需要添加新的方法，可以直接在抽象类中添加具体的实现，子类可以不进行变更；而对于接口则不行，如果接口进行了变更，则所有实现这个接口的类都必须进行相应的改动。
四. 什么时候使用抽象类和接口
- 如果你拥有一些方法并且想让它们中的一些有默认实现，那么使用抽象类。
2.如果你想实现多重继承，那么你必须使用接口。由于Java不支持多继承，子类不能够继承多个类，但可以实现多个接口。因此你就可以使用接口来解决它。
3.如果基本功能在不断改变，那么就需要使用抽象类。如果不断改变基本功能并且使用接口，那么就需要改变所有实现了该接口的类
下面看一个网上流传最广泛的例子（我没有想到比这个好的例子）：门和警报的例子：门都有open( )和close( )两个动作，此时我们可以定义通过抽象类和接口来定义这个抽象概念：
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() {
//....
}
}
小结：
类是对事物的抽象
抽象类是对特定事物的抽象
接口是对抽象的抽象
