接口的概念
java中的接口用于描述类应该具备什么样的功能，而不给出具体的实现，一个类可以“实现”多个接口
【注意】接口不是类，而是对类的一组描述
还是让我们通过一个例子来看看接口如何运作吧！
java文件结构：
├─myInterface.java └─Myclass.java
myInterface.java :
public interface myInterface {
int function ( int arg ) ;
}
Myclass.java:
public class Myclass implements myInterface{
public int function(int arg) {
;
}
}
在上面这个例子中，我们称 Myclass实现了（implements了）myInterface这个接口
接口的一些特性
1.置入一个接口的所有字段都自动具有static 和final 属性, 也就是说，所有的字段都是静态常量
2.字段和方法只能被public修饰， 而不能被private或者protected修饰（你可以不写出public，因为默认就是由public修饰的）
例如，如下用private修饰一个字段会导致报错
public interface myInterface {
private int a;
}
报的错误是：
Illegal modifier for the interface field myInterface.a; only public, static & final are permitted
对比是学习的一种方式，下面我对接口的介绍，将在一系列的对比中展开
接口和超类的差异
我们发现，接口的定义方式和使用和超类很相似，例如：
超类的定义和使用:
public class superClass { ... }
public class subClass extends superClass { ...}
接口的定义和使用：
public interface myInterface { ... }
public class Myclass implements myInterface{ ...}
就使用而言，超类通过class关键字定义， 并通过extends去“继承”，而接口通过interface关键字定义，并通过implement去“实现”
那么“接口”和“超类”有什么不同呢？
超类是一个“模板”，而接口是一种“契约”
超类的作用是为子类提供可复用（继承）的方法和域，并允许子类在此基础上添加新的方法和域，超类是一个“模板”
而接口实现却不一样，接口并不提供给子类能够使用的方法。相反，接口约定了一组方法，并强制要求implements了（也即实现了）这个接口的类去“实现”接口约定的方法，接口是一种“契约”
如果你在implements了接口的类中没有按要求“实现”接口约定的方法的话，是会导致报错的,例如：
报的错误是：
The type Myclass must implement the inherited abstract method myInterface.function(int)
我们通过提示的quick fix修复一下：
可以看到，“实现”了接口约定的这个function方法后，报错消失了， 那怎么才算符合约定呢？这要求对应的方法的返回值类型和参数类型都和接口里的相同
让我对接口和超类的作用打个比方：
超类继承
我们假设有这么一个年轻人（子类），如果他有一个有钱的老爸（超类），那么因为他可以直接从父亲（超类）获得这一部分财产：房子，车和钱（继承的方法），甚至于他可以不用工作，游手好闲（可以“拥有”超类提供的方法）。当然了，如果他还算是个有上进心的年轻人的话， 他也可以在已有基础上，自己打拼挣一些钱（属于子类自身的方法，或者覆盖超类原有的方法）
接口实现
但如果这个年轻人（类）生于一个相对普通的家庭，而且还有一个望子成龙的母亲（接口）的话，那么在他妈的严格要求下，他就必须靠自己的努力工作,去取得房子，车和钱（实现接口中约定的方法），并且他妈可能会要求他： 达不到目标就不要回来了！ （如果没有实现接口约定的全部方法会报错）
代码如下：
超类继承
SuperClass.java:
public class SuperClass {
public String getMoney () {// 获取金钱
return "Money";
}
public String getHouse () { // 获取房子
return "house";
}
public String getCar () { // 获取车子
return "car";
}
}
Myclass.java:
public class Myclass extends SuperClass{
public String getAll () {
return getMoney() + " " + getCar() + " " + getHouse();
}
public static void main(String args []) {
Myclass me = new Myclass();
System.out.println(me.getAll());
}
}
运行结果：
Money car house
接口实现：
myInterface.java:
public interface myInterface {
public String getMoney ();
public String getHouse ();
public String getCar ();
}
Myclass.java:
public class Myclass implements myInterface{
public String getMoney () {
return "Money";
}
public String getHouse () {
return "house";
}
public String getCar () {
return "car";
}
public String getAll () {
return getMoney() + " " + getCar() + " " + getHouse();
}
public static void main(String args []) {
Myclass me = new Myclass();
System.out.println(me.getAll());
}
}
运行结果：
Money car house
接口和抽象类的差异
接口和抽象类在使用形式上非常相似
AbstractClass.java:
abstract class AbstractClass {
public abstract int function ();
}
MyClass.java:
public class MyClass extends AbstractClass {
public int function() {
;
}
}
接口和抽象类的共同点
1.都要求类(或子类)实现某一组约定的方法
2. 不能实例化
接口和抽象类的不同点
1.抽象类是归根结底还是类，它是对某一具体的类的抽象，而接口是对某一行为的抽象。
2.就抽象这一特性而言，抽象类关注的是整体，而接口关注的是局部。
3.抽象类约定的方法是从该抽象类的子类中提取出来的，而接口约定的方法是从许多不同的类中根据共通的部分提取出来的
我们上面提到，正因为“抽象类是归根结底还是类”，而接口不是类，所以：
1.抽象类可以有构造器，而接口不能有构造器
2.抽象类的抽象方法可以有public、protected，default修饰符，接口方法修饰符只能是public。
3.抽象类的抽象方法可以有main方法，接口不允许有main方法
接口实现/接口继承和类继承的差异
1.一个类可以实现多个接口
2. 一个接口可以继承另外一个接口，且允许“接口多继承”
一个类可以实现多个接口
为了避免多继承带来的复杂性，java舍弃了多继承的特性，也即一个类不能有多个超类：
// 没有这种写法，这是非法行为
public class MyClass extends SuperClass1,SuperClass2 { }
但是一个类却允许实现多个接口，例如：
public class MyClass implements interface1, interface2 { }
具体的例子：
我们有这样一个情景： 一个技术小白（例如我），每天要做的事情除了上学读书外，剩下的事件用来写技术文章
这个情景转化为代码是这样的： 有一个 TechXiaoBai类， 这个类要实现两个接口：Education和Blog，其中Education接口约定了study方法，而Blog接口约定了 Education接口
java文件结构：
├─TechXiaoBai.java // 主力类 ├─Blog.java // 接口1 └─Education.java // 接口2
TechXiaoBai.java
public class TechXiaoBai implements Blog, Education {
// 作为一名技术小白每天要做的事情
public void study() { }
public void writeArticle() { }
}
Blog.java：
public interface Blog {
void writeArticle (); // 写文章
}
Education.java:
public interface Education {
void study(); // 学习
}
图示：
java允许“接口多继承”
java除了允许一个类继承多个接口外，还允许一个接口继承另外一个接口，甚至还允许“接口多继承”
具体的例子（紧接上面）：
我们有这样一个情景： 在技术小白读书的过程中，具体又分为几个方面：本科生教育和研究生教育，假设这个技术小白想要读研的话——
那么这个情景转化为代码是这样的： 我们为上面提到的Education接口再提供两个扩展性的“父”接口：Undergraduate接口和Postgraduate接口
Undergraduate接口约定了learnBasicKowledge方法（学习基础知识），而Postgraduate接口约定了doScientificRearch方法（搞科研）
代码如下：
java文件结构：
├─TechXiaoBai.java // 主力类 ├─Blog.java // 接口1 ├─Education.java // 接口2 ├─Undergraduate.java // 新增被Education接口继承的接口,接口2.1 └─Postgraduate.java // 新增被Education接口继承的接口,接口2.2
Undergraduate.java:
// “本科生”接口
public interface Undergraduate {
void learnBasicKowledge(); // 学习基础知识
}
Postgraduate.java：
// 研究生接口
public interface Postgraduate {
void doScientificRearch(); // 搞一搞科研啦
}
Education.java:
public interface Education extends Undergraduate, Postgraduate{
void study(); // 学习
}
TechXiaoBai.java:
public class TechXiaoBai implements Blog, Education {
// 每天要做的事情
public void study() { }
public void writeArticle() { }
public void learnBasicKowledge() { } // 新增方法
public void doScientificRearch() { } // 新增方法
}
图示：
实际上：
public interface Education extends Undergraduate, Postgraduate{
void study(); // 学习
}
相当于将Eduation接口变成了：
public interface Education extends Undergraduate, Postgraduate{
void study(); // 学习
void learnBasicKowledge(); // 学习基础知识
void doScientificRearch(); // 搞一搞科研啦
}
接口存在的意义
了解接口的意义，让我们从一个例子开始，java中的Arrays类的Arrays.sort方法可以对对象类型的数组元素进行排序（Arrays.sort(Object [])）,但是前提是对象所属的类必须实现了Comparable接口，而Comparable接口约定了compareTo方法。
Comparable接口的代码如下：
public interface Comparable<T>
{
int compareTo(T other) // parameter has type T
}
Comparable接口对compareTo方法的实现的具体要求是：如果当前对象大于参数对象则返回正数，相反则返回负数，相等返回0
下面是一个示范例子：
有一个Student类，类中有实例变量score（分数）， 我们创建一个Student类型的数组存放不同的Student对象并根据其score的大小进行从小到大的排序：
import java.util.Arrays;
public class Student implements Comparable<Student>{
private int score; // 每个学生的分数
public Student (int score) {
this.score = score;
}
public int getScore () { // 获取每个学生对象的分数
return this.score;
}
@Override
public int compareTo(Student other) { // 实现Comparable接口约定的compareTo方法
return this.score - other.score;
}
public static void main (String [] args){
Student [] stuArray = ]; // 声明Student类型的数组
stuArray[] = ); // 将三个Student对象赋给数组
stuArray[] = );
stuArray[] = );
stuArray[] = );
Arrays.sort(stuArray); // 进行从小到大的排序
; i<stuArray.length; i++){
System.) +"个学生对象的分数：" + stuArray[i].getScore());
}
}
}
运行结果：
排序后数组里第1个学生对象的分数： 排序后数组里第2个学生对象的分数： 排序后数组里第3个学生对象的分数： 排序后数组里第4个学生对象的分数：
接口声明了一个类应该实现哪些功能，但它又并不负责这些功能的具体实现，它告诉了我们这个类“用来做什么”，但是不告诉我们“具体怎么做”
1.它为各种不同的方法的实现提供了足够的*度，例如用来为数组元素排序的ArrayList.sort方法，是没有办法指定一种特定的排序的方式的，让我们思考下，数组元素是“学生类的对象”和“老师类的对象”的时候排序的思路肯定不一样， 就算数组元素是某一特定的对象例如“学生对象”，根据需求的不同排序的方式也会有很大的不同：按照年龄来排序？按照成绩来排序？或者是按照姓氏的首字母排序？
指定一个没有固定实现的接口就可以为这种情况提供足够的*度
2. 在ArrayList.sort中可能存在如下的语句：
){
// 对a[i]和a[j]进行排序
}
因为Comparable接口要求实现这接口的类必须具有compareTo方法，所以在上面的例子中，通过接口，我们就可以确保a数组的数组元素一定是拥有compareTo方法,从而通过编译器的检查
【完】