抽象类：
当编写一个类时，常常会为该类定义一些方法，这些方法用以描述该类的行为方式，那么这些方法都有具体的方法体。但在某些情况下，某个父类只是知道其子类应该包含怎样的方法，但无法准确地知道这些子类如何实现这些方法。例如定义了一个Shape类，这个类应该提供一个计算周长的方法calPerimeter()，但不同Shape子类对周长的计算方法是不一样的，即Shape类无法准确地知道其子类计算周长的方法。
可能有读者会提出，既然Shape类不知道如何实现calPerimeter()方法，那就干脆不要管它了！这不是一个好思路：假设有一个Shape引用变量，该变量实际上引用到Shape子类的实例，那么这个Shape变量就无法调用calPerimeter()方法，必须将其强制类型转换为其子类类型，才可调用calPerimeter()方法，这就降低了程序的灵活性。
如何既能让Shape类里包含calPerimeter()方法，又无须提供其方法实现呢？使用抽象方法即可满足该要求：抽象方法是只有方法签名，没有方法实现的方法。
抽象方法和抽象类必须使用abstract修饰符来定义，有抽象方法的类只能被定义成抽象类，抽象类里可以没有抽象方法。规则如下。
1.抽象类必须使用abstract修饰符来修饰，抽象方法也必须使用abstract修饰符来修饰，抽象方法不能有方法体。
2.抽象类不能被实例化，无法使用new关键字来调用抽象类的构造器创建抽象类的实例。即使抽象类里不包含抽象方法，这个抽象类也不能创建实例。
3.抽象类可以包含成员变量、方法（普通方法和抽象方法都可以）、构造器、初始化块、内部类（接口/枚举）5种成分。抽象类的构造器不能创建实例，主要是用于被其子类调用。
4.含有抽象方法的类（包括直接定义了一个抽象方法；或继承了 一个抽象父类，但没有完全实现父类包含的抽象方法；或实现 了一个接口，但没有完全实现接口包含的抽象方法三种情况）只能被定义成抽象类。
注意：
归纳起来，抽象类可用“有得有失”4个字来描述。“得”指的是抽象类多了一个能力：抽象类可以包含抽象方法；“失”指的是抽象类失去了一个能力：抽象类不能用于创建实例。
定义抽象方法只需在普通方法上增加abstract修饰符，并把普通方法的方法体（也就是方法后花括号括起来的部分）全部去掉，并在方法后增加分号即可。
注意：
抽象方法和空方法体的方法不是同一个概念。例如，public abstract void test();是一个抽象方法，它根本没有方法体，即方法定义后面没有一对花括号；但public void test(){}方法是一个普通方法，它已经定义了方法体，只是方法体为空，即它的方法体什么也不做，因此这个方法不可使用abstract来修饰。
定义抽象类只需在普通类上增加abstract修饰符即可。甚至一个普通类（没有包含抽象方法的类）增加abstract修饰符后也将变成抽象类。

抽象类里既包含了初始化块，也包含了构造器，这些都不是在创建这个类的对象时被调用
的，而是在创建其子类的实例时被调用。抽象类不能用于创建实例，只能当作父类被其他子类继承。
子类继承了该抽象类，如果这个子类是普通类，则必须实现该抽象父类中的抽象方法。因此可以创建该子类的实例，可以让一个父类类型的引用变量指向子类对象。也就是抽象类和抽象方法对多态更加支持的灵活。

final和abstract永远不能同时使用：
当使用abstract修饰类时，表明这个类只能被继承；
当使用abstract修饰方法时，表明这个方法必须由子类提供实现（即重写）。
当使用final修饰的类不能被继承，final修饰的方法不能被重写。
因此final和abstract永远不能同时使用。
注意：
abstract不能用于修饰成员变量，不能用于修饰局部变量，即没有抽象变量、没有抽象成员变量等说法；abstract也不能用于修饰构造器，没有抽象构造器，抽象类里定义的构造器只能是普通构造器。

abstract/static/private的对比：
当使用static修饰一个方法时，表明这个方法属于该类本身，即通过类就可调用该方法，但如果该方法被定义成抽象方法，则将导致通过该类来调用该方法时出现错误（调用了一个没有方法体的方法肯定会引起错误）。因此static和abstract不能同时修饰某个方法，即没有所谓的类抽象方法。
注意：
static和abstract并不是绝对互斥的，static和abstract虽然不能同时修饰某个方法，但它们可以同时修饰内部类。
注意：
abstract关键字修饰的方法必须被其子类重写才有意义，否则这个方法将永远不会有方法体，但是private修饰的方法子类是不能重写的，因此abstract方法不能定义为private访问权限，即private和abstract不能同时修饰方法。

抽象类有什么作用？
抽象类不能创建实例，只能当成父类来被继承。从语义的角度来看，抽象类是从多个具体类中抽象出来的父类，它具有更高层次的抽象。从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为其子类的模板，从而避免了子类设计的随意性。
抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会大致保留抽象类的行为方式。
如果编写一个抽象父类，父类提供了多个子类的通用方法，并把一个或多个方法留给其子类实现，这就是一种模板模式，模板模式也是十分常见且简单的设计模式之一。在抽象父类中，父类的普通方法依赖于一个抽象方法，而抽象方法则推迟到子类中提供实现？

抽象类了解了----那么接口呢？
抽象类是从多个类中抽象出来的模板，如果将抽象进行到底，则能提炼出更抽象的接口 （interface）。Java 9对接口进行了改进，允许在接口中定义默认方法和类方法，默认方法和类方法都可以提供方法实现，Java 9为接口增加了一种私有方法，私有方法也可提供方法实现。

接口怎么定义呢？
定义接口不再使用class关键字，而是使用interface关键字。
1.修饰符可以是public或者省略，如果省略了public访问控制符，则默认采用包权限访问控制符，即只有在相同包结构下才可以访问该接口。
2.接口名应与类名采用相同的命名规则，即如果仅从语法角度来看，接口名只要是合法的标识符即可；如果要遵守Java可读性规范，则接口名应由多个有意义的单词连缀而成，每个单词首字母大写，单词与单词之间无须任何分隔符。接口名通常能够使用形容词。
3.一个接口可以有多个直接父接口，但接口只能继承接口，不能继承类。

只有在Java 8以上的版本中才允许在接口中定义默认方法、类方法。平时用的最多的就是定义方法，但是接口里可以有成员变量（只能是静态常量），由于接口定义的是一种规范，因此接口里不能包含构造器和初始化块定义。接口里也可以包含方法（只能是抽象实例方法、类方法、默认方法或私有方法）、内部类（包括内部接口、枚举）定义【默认都采用public
static两个修饰符，不管定义时是否指定这两个修饰符，系统都会自动使用public static对它们进行修饰】。对比下来，接口比类里少了 构造器 和 初始化快定义。
接口里定义的是多个类共同的公共行为规范，因此接口里的常量、方法、内部类和内部枚举都是public访问权限。 定义接口成员时，可以省略访问控制修饰符，如果指定访问控制修饰符，则只能使用public访问控制修饰符。
Java 9为接口增加了一种新的私有方法，其实私有方法的主要作用就是作为工具方法，为接口中的默认方法或类方法提供支持。私有方法可以拥有方法体，但私有方法不能使用default修饰。私有方法可以使用static修饰，也就是说，私有方法既可是类方法，也可是实例方法。
对于接口里定义的静态常量而言，它们是接口相关的，因此系统会自动为这些成员变量增加static和final两个修饰符

public interface PhoneHandle {
    String bizcode = "fc-sydc-58shangbantong-app";
}

也就是说，在接口中定义成员变量时，不管是否使用public static final修饰符， 接口里的成员变量总是使用这三个修饰符来修饰，因此即使另一个类处于不同包下，也可以通过接口来访问接口里的成员变量。而且接口里没有构造器和初始化块，因此接口里定义的成员变量只能在定义时指定默认值。
接口里定义的方法只能是抽象方法、类方法、默认方法或私有方法，一般使用默认方法居多。因此如果不是定义默认方法、类方法或私有方法，系统将自动为普通方法增加abstract修饰符；

public interface PhoneHandle {
    Boolean match(String type);
}

定义接口里的普通方法时不管是否使用 public abstract修饰符 ，接口里的普通方法总是
使用 public abstract来修饰。接口里的普通方法不能有方法实现（方法体）；但类方法、默认方法、私有方法都必须有方法实现（方法体）。

接口的默认方法其实就是实例方法，默认方法必须使用default修饰，该方法不能使用static修饰，无论程序是否指定，默认方法总是使用public修饰——如果开发者没有指定public，系统会自动为默认方法添加public修饰符。由于默认方法并没有static修饰，因此不能直接使用接口来调用默认方法，需要使用接口的实现类的实例来调用这些默认方法。
提示：
接口的默认方法其实就是实例方法，但由于早期Java的设计是：接口中的实例方法不能有方法体；Java 8也不能直接“推倒” 以前的规则，因此只好重定义一个所谓的“默认方法”，默认方法就是有方法体的实例方法。
从Java 8开始，在接口里允许定义类方法，类方法必须使用static修饰，该方法不能使用default修饰，无论程序是否指定，类方法总是使用public修饰——如果开发者没有指定public，系统会自动为类方法添加public修饰符，类方法可以直接使用接口来调用。
Java 9增加了带方法体的私有方法，这也是Java 8埋下的伏笔：Java 8允许在接口中定义带方法体的默认方法和类方法—这样势必会引发一个问题，当两个默认方法（或类方法）中包含一段相同的实现逻辑时，程序必然考虑将这段实现逻辑抽取成工具方法，而工具方法
是应该被隐藏的，这就是Java 9增加私有方法的必然性。
接口可被当成一个特殊的类，因此一个Java源文件里最多只能有一个public接口，如果一个Java源文件里定义了一个public接口，则该源文件的主文件名必须与该接口名相同。

那么问题来了，一个类继承了一个类且同时实现了多个接口，那有什么要求呢？
一个类实现了一个或多个接口之后，这个类必须完全实现这些接口里所定义的全部抽象方法（也就是重写这些抽象方法）；否则该类将保留从父接口那里继承到的抽象方法，该类也必须定义成抽象类。
一个类实现某个接口时，该类将会获得接口中定义的常量（成员变量）、方法等，因此可以把实现接口理解为一种特殊的继承，相当于实现类继承了一个彻底抽象的类（相当于除默认方法外，所有方法都是抽象方法的类）。
A类实现了接口1和接口2，因此A类的对象既可直接赋给接口1引用变量，也可直接赋给
接口2引用变量。仿佛Printer类既是Output类的子类，也是Product类的子类，这就是Java提供的模拟多继承。
注意：
实现接口方法时，必须使用public访问控制修饰符，因为接口里的方法都是public的，而子类（相当于实现类）重写父类方法时访问权限只能更大或者相等，所以实现类实现接口里的方法时只能使用public访问权限。
接口不能显式继承任何类，但所有接口类型的引用变量都可以直接赋给Object类型的引用变量。所以在上面程序中可以把Product类型的变量直接赋给Object类型变量，这是利用向上转型来实现的，因为编译器知道任何Java对象都必须是Object或其子类的实例，Product类型的对象也不例外（它必须是Product接口实现类的对象，该实现类肯定是Object的显式或隐式子类）。

说了这么多，那么接口和抽象类到底有什么区别和联系呢？
先说共同点：
1.接口和抽象类都不能被实例化，它们都位于继承树的顶端，用于被其他类实现和继承。
2.接口和抽象类都可以包含抽象方法，实现接口或继承抽象类的普通子类都必须实现这些抽象方法。
再说区别：
1.接口作为系统与外界交互的窗口，接口体现的是一种规范。对于接口的实现者而言，接口规定了实现者必须向外提供哪些服务（以方法的形式来提供）；对于接口的调用者而言，接口规定了调用者可以调用哪些服务，以及如何调用这些服务（就是如何来调用方法）。当在一个程序中使用接口时，接口是多个模块间的耦合标准；当在多个应用程序之间使用接口时，接口是多个程序之间的通信标准。从某种程度上来看，接口类似于整个系统的“总纲”，它制定了系统各模块应该遵循的标准，因此一个系统中的接口不应该经常改变。一旦接口被改变，对整个系统甚至其他系统的影响将是辐射式的，导致系统中大部分类都需要改写。
抽象类则不一样，抽象类作为系统中多个子类的共同父类，它所体现的是一种模板式设计。抽象类作为多个子类的抽象父类，可以被当成系统实现过程中的中间产品，这个中间产品已经实现了系统的部分功能（那些已经提供实现的方法），但这个产品依然不能当成最终产品，必须有更进一步的完善，这种完善可能有几种不同方式。
2.接口和抽象类在用法上也存在如下差别。
接口里只能包含抽象方法、静态方法、默认方法和私有方法，不能为普通方法提供方法实现；抽象类则完全可以包含普通方法。
3.接口里只能定义静态常量，不能定义普通成员变量；抽象类里则既可以定义普通成员变量，也可以定义静态常量。
4.接口里不包含构造器；抽象类里可以包含构造器，抽象类里的构造器并不是用于创建对象，而是让其子类调用这些构造器来完成属于抽象类的初始化操作。
5.接口里不能包含初始化块；但抽象类则完全可以包含初始化块。
6.一个类最多只能有一个直接父类，包括抽象类；但一个类可以直接实现多个接口，通过实现多个接口可以弥补Java单继承的不足。