一：概念
接口是功能的集合。同樣可以看做一種數據類型，是比抽象類更為抽象的“類”。
接口描述應該具備的方法，並沒有具體的實現。具體實現由接口的實現類（相當於接口的子類來完成）。
好處：
使功能和實現分離，優化了程序設計。
二：語法
使用關鍵字interface關鍵字來定義。
定義的接口文件仍然是.java文件。雖然聲明的時候使用interface關鍵字，編譯之后仍然是.class
文件。接口我們可以把他看做是一種只包含了功能聲明的特殊類。
定義格式:
public interface 接口名字{
抽象方法1（public abstract 返回值類型 方法名字(參數列表);）
抽象方法1（public abstract 返回值類型 方法名字(參數列表);）
抽象方法1（public abstract 返回值類型 方法名字(參數列表);）
.......
}
1 package com.company; 2 3 public interface Myinterface { 4 /** 5 *接口定義： 6 * 修飾符 interface 接口名字 7 * 方法的定義: 8 * public abstract 返回值類型 方法名字 (參數列表) 9 * 其中 public 修飾符必須是 public 或者不寫，不寫該方法的訪問權限也是public。方法為抽象方法,所以用abstract來修飾. 10 * 成員的變量的定義:必須是常量且修飾符為public . 11 */ 12 public static final int c=22; 13 public abstract int myinter(); 14 }
注意：
在接口內的方法，必須是public修飾符，以及為抽象方法（abstract）。
三：接口的實現
我們把實現接口的類叫做接口的實現。
1 package com.company; 2 3 /** 4 * 接口的實現語法： 5 * 使用關鍵字implements. 6 * 修飾符 類名字 implements 接口名字{ 7 * public 返回值類型 抽象方法的名字{ 8 * 方法體. 9 * } 10 * } 11 * 類的名字 關鍵字 接口名字 12 * public class Myimple implements Myinterface 13 */ 14 15 16 17 public class Myimple implements Myinterface { 18 public int myinter(){ 19 return 2; 20 }; 21 }
注意:
在接口中默認方法都是抽象的（abstract）,不管是否使用public abstract，都一樣
抽象的方法重寫，修飾符是public 注意訪問權限 只能是public.而且是普通方法。（沒有abstract，abstract是抽象方法的定義。）
類是接口的實現，類似於類是接口的子類，接口繼承。但是實際上類是接口的實現。
如果接口中有多個抽象方法，實現類需要把接口的抽象方法都一一實現。
接口類的中的抽象方法和接口的成員變量訪問權限都是public，寫和不寫都是這個權限，實現類中的方法的權限也必須是public。否則報錯！！！
如果一個實現類中並沒有實現接口的所有的抽象方法，如果依然是普通類，會報錯，普通類需要實現所有的接口的方法，而實現類變為抽象類就不會報錯。也就是說
實現部分接口的抽象方法，實現類是抽象類。
接口:
1 package com.company; 2 3 public interface Myinterface { 4 /** 5 *接口定義： 6 * 修飾符 interface 接口名字 7 * 方法的定義: 8 * public abstract 返回值類型 方法名字 (參數列表) 9 * 其中 public 修飾符必須是 public 或者不寫，不寫該方法的訪問權限也是public。方法為抽象方法,所以用abstract來修飾. 10 * 成員的變量的定義:必須是常量且修飾符為public . 11 */ 12 public static final int c=22; 13 public abstract int myinter(); 14 public abstract void myinter1(); 15 }
實現類:
1 public abstract class Myimple implements Myinterface { 2 public int myinter(){ 3 return 2; 4 }; 5 }
調用：
通過初始化實現類對象來調用相應的方法：
1 package com.company; 2 3 public class Mytest { 4 public static void main(String ... arg){ 5 Myimple shixian=new Myimple(); 6 System.out.println(shixian.myinter()); 7 } 8 }
接口的多實現：
類的繼承只能單繼承，而接口不一樣，可以同實現類實現多個接口，這個也是比抽象類更加靈活。
實現類C可以同時實現接口A和B。
接口A：
1 package com.company; 2 3 public interface Myinterface { 4 /** 5 *接口定義： 6 * 修飾符 interface 接口名字 7 * 方法的定義: 8 * public abstract 返回值類型 方法名字 (參數列表) 9 * 其中 public 修飾符必須是 public 或者不寫，不寫該方法的訪問權限也是public。方法為抽象方法,所以用abstract來修飾. 10 * 成員的變量的定義:必須是常量且修飾符為public . 11 */ 12 public static final int c=22; 13 public abstract int myinter(); 14 15 }
接口B：
1 package com.company; 2 3 public interface Myinterfac_b { 4 public abstract int myinter(); 5 }
實現C：
1 public class Myimple implements Myinterface ,Myinterfac_b{ 2 public int myinter(){ 3 return 2; 4 }; 5 }
因為接口A 和B的抽象方法是一樣，所以實現類C可以重寫一個類即可。
但是前提：
1：重寫方法 返回值一樣。如果不一樣的話，需要分別實現，不能一起實現。
2：如果方法的參數列表不一樣。我們可以重載。
接口A：
1 package com.company; 2 3 public interface Myinterface { 4 /** 5 *接口定義： 6 * 修飾符 interface 接口名字 7 * 方法的定義: 8 * public abstract 返回值類型 方法名字 (參數列表) 9 * 其中 public 修飾符必須是 public 或者不寫，不寫該方法的訪問權限也是public。方法為抽象方法,所以用abstract來修飾. 10 * 成員的變量的定義:必須是常量且修飾符為public . 11 */ 12 public static final int c=22; 13 public abstract int myinter(String a); 14 15 }
接口B：
1 package com.company; 2 3 public interface Myinterfac_b { 4 public abstract int myinter(); 5 }
實現C：
package com.company; public class Mytest { public static void main(String ... arg){ Myimple shixian=new Myimple(); System.out.println(shixian.myinter()); System.out.println(shixian.myinter("ok")); } }
注意：
決定方法的差異是方法的簽名，方法的簽名包含方法的名字和參數！
接口的多繼承：
接口可以進行多繼承，但是最后子接口，在被實現的時候，需要實現所有父接口的抽象方法。也就是說在java中有多繼承的概念。
接口A：
1 public interface Myinterface { 2 /** 3 *接口定義： 4 * 修飾符 interface 接口名字 5 * 方法的定義: 6 * public abstract 返回值類型 方法名字 (參數列表) 7 * 其中 public 修飾符必須是 public 或者不寫，不寫該方法的訪問權限也是public。方法為抽象方法,所以用abstract來修飾. 8 * 成員的變量的定義:必須是常量且修飾符為public . 9 */ 10 public static final int c=22; 11 public abstract int myinter(String a); 12 13 }
接口B：
1 package com.company; 2 3 public interface Myinterfac_b { 4 public abstract int myinter(); 5 }
接口C：
1 package com.company; 2 3 public interface Myinter_c extends Myinterfac_b,Myinterface { 4 public abstract double myinter_c(); 5 }
實現：
1 public class Myimple implements Myinter_c{ 2 public int myinter(){ 3 return 2; 4 }; 5 6 @Override 7 public int myinter(String a) { 8 return 3; 9 } 10 public double myinter_c(){ 11 return 4; 12 } 13 }
調用：
1 package com.company; 2 3 public class Mytest { 4 public static void main(String ... arg){ 5 Myimple shixian=new Myimple(); 6 System.out.println(shixian.myinter()); 7 System.out.println(shixian.myinter("ok")); 8 System.out.println(shixian.myinter_c()); 9 } 10 }
注意：
最后實現：如果實現的C的接口時候，實現類中需要把各個抽象方法都要一一實現。這叫做接口的多繼承。
抽象類和接口的區別：
抽象類：是事務共有的功能，但是功能由於具體的對象的不同導致實現內容不一樣。
接口：是事務額外的功能，如果事務想具備這個功能，需要定義相應的接口，由實現類來實現。
人的共有的功能：吃和睡覺。但是每個吃什么和怎么睡覺是不一樣的。但都屬於人的共有的功能。人是否編程功能，不一定，屬於人的額外功能。所以吃和睡是抽象，編程是接口。
抽象類：
1 package com.company; 2 3 public abstract class Person_t { 4 public abstract void eat(); 5 public abstract void sleep(); 6 public String work(){ 7 return "make money"; 8 } 9 }
接口：
1 package com.company; 2 3 public interface Per_in { 4 public abstract void biancheng(); 5 }
實現類和實現抽象類的抽象方法：
1 package com.company; 2 3 4 5 public class Beav extends Person_t implements Per_in { 6 public void eat(){ 7 System.out.println("apple"); 8 } 9 public void sleep(){ 10 System.out.println("sleep at 500"); 11 } 12 public void biancheng(){ 13 System.out.println("java"); 14 } 15 }
調用類：
1 package com.company; 2 3 public class Per_Test { 4 public static void main(String ... args){ 5 Person_t new_Per=new Beav(); 6 new_Per.eat(); 7 new_Per.sleep(); 8 Beav new_be=new Beav(); 9 new_be.biancheng(); 10 } 11 }
注意：
抽象類中不一定只有抽象方法，也可以有普通方法。抽象類通過子類來調用和實現抽象方法和普通方法。
接口只有抽象方法和常量。沒有普通方法。
接口需要實現（implements），抽象方法需要繼承（extends），抽象是多態實現，而接口是功能和實現分離。
接口也可以這么寫 接口 變量 =new 子類的構造器();這是接口的多態。
1 package com.company; 2 3 public class Per_Test { 4 public static void main(String ... args){ 5 Person_t new_Per=new Beav(); 6 new_Per.eat(); 7 new_Per.sleep(); 8 Per_in new_be=new Beav(); 9 new_be.biancheng(); 10 } 11 }
多態是指對象在不同的情形下，對應的類型不同。接口通過實現類來實現多態，類通過繼承，子類實現多態。