在講解介面之前，抽象類別是繞不過去的一個概念，介面可以認為是比抽象類別還要抽象的類別。
什麼是抽象類別？ 「包含一個或多個抽象方法的類別就是抽象類，抽象方法即沒有方法體的方法」，抽象方法和抽象類別都必須宣告為 abstract#。例如：
<code>// 抽象类<br>public abstract class Person {<br> // 抽象方法<br> public abstract String getDescription();<br>}</code>記得！ 「除了抽象方法之外，抽象類別還可以包含具體資料和具體方法」。例如， 抽象類別 Person 也保存姓名和一個回傳姓名的具體方法：
<code>public abstract class Person{<br> private String name;<br> public Person(String name){<br> this.name = name ;<br> }<br> public abstract String getDescription();<br> public String getName(){<br> return name;<br> }<br>}</code>❝許多程式設計師都會「錯誤」的認為，在抽象類別中不能包含具體方法。其實這也是介面和抽象類別的不同之處，介面中是不能包含具體方法的。
❞
「抽象類別不能被實例化」。也就是說，如果將一個類別宣告為 abstract, 就不能建立這個類別的物件。
<code>new Person("Jack"); // Error</code>可以定義一個抽象類別的物件變量， 但是它只能引用非抽象子類別的物件。假設 Student 類別是 Person 的非抽象子類別：
<code>Person p = new Student("Jack"); // Right</code>所謂非抽象子類別就是說，如果建立一個繼承抽象類別的子類別並為之建立對象，那麼就「必須為父類別的所有抽象方法提供方法定義」。如果不這麼做（可以選擇不做），子類別仍然是抽象類，編譯器會強制我們為新類別加上 abstract 關鍵字。
下面定義擴展抽象類別 Person 的具體子類別 Student：
<code>public class Student extends Person { <br> private String major; <br> public Student(String name, String major) { <br> super(name); <br> this.major = major; <br> } <br> @Override<br> public String getDescription(){ // 实现父类抽象方法<br> return "a student majoring in " + major; <br> } <br>} </code>在 Student 類別中實現了父類別中的抽象方法 getDescription 。因此，「在 Student類別中的全部方法都是非抽象的， 這個類別不再是抽象類別」。
???? 呼叫如下：
<code>Person p = new Student("Jack","Computer Science");<br>p.getDescription();<br></code>由於無法建構抽象類別 Person的對象， 所以變數 p 永遠不會引用 Person 對象， 而是引用諸如 Student這樣的特定子類別對象， 而這些物件中都重寫了 getDescription方法。
介面的本質其實也是一個類，而且是比抽象類別還要抽象的類別。怎麼說呢？抽象類別是能夠包含具體方法的，而介面杜絕了這個可能性，「在 Java 8 之前，介面非常純粹，只能包含抽象方法，也就是沒有方法體的方法」。而 Java 8 中介面出現了些許的變化，開始允許介麵包含預設方法和靜態方法，這個下文會講解。
Java 使用關鍵字 interface 而不是 class 來建立介面。和類別一樣，通常我們會在關鍵字 interface 前加上 public 關鍵字，否則介面只有套件存取權限，只能在介面相同的套件下才能使用它。
<code>public interface Concept {<br> void idea1();<br> void idea2();<br>}</code> 同樣的，介面中既然有抽象方法，那麼他就需要被擴充（繼承）。使用 implements 關鍵字讓一個類別擴充某個特定介面（或一組介面），簡單來說：介面只是外形，現在這個擴充子類別要說明它是如何運作的。
<code>class Implementation implements Concept {<br> @Override<br> public void idea1() {<br> System.out.println("idea1");<br> }<br> <br> @Override<br> public void idea2() {<br> System.out.println("idea2");<br> }<br>}<br></code>這裡要注意的是，你可以選擇明確地宣告介面中的方法為 public，但是「即使你不這麼做，它們也是 public 的」。所以當實作一個介面時，來自介面中的方法必須定義為 public。否則，它們只有套件存取權限，這樣在被繼承時，它們的可存取權限就被降低了，這是 Java 編譯器所不允許的。
另外，介面中是允許出現常數的，與介面中的方法都自動地被設定為 public—樣，「介面中的域將會自動被設定為 public static final 類型」，例如：
<code>public interface Concept {<br> void idea1(); // public void idea1();<br> // 静态属性<br> double item = 95; // a public static final constant<br>}</code> ❝可以將介面方法標記為
❞public，將網域標記為public static final。有些程式設計師出於習慣或提高清晰度的考慮， 願意這樣做。但Java 語言規格卻「建議不要書寫這些多餘的關鍵字」。
介面和類別其中不同的一點就是，我們「無法像類別一樣使用 new 運算子來實例化一個介面」：
<code>x = new Concept(. . .); // ERROR</code>
原因也很簡單，介面連具體的建構方法都沒有，肯定是無法實例化的。
當然， 儘管不能建構介面的對象，宣告介面的變數還是可以的：
<code>Concept x; // OK</code>
接口变量必须引用实现了接口的类对象：
<code>x = new Implementation(. . .); // OK provided Implementation implements Concept</code>
接下来， 如同使用 instanceof 检查一个对象是否属于某个特定类一样， 也可以使用 instanceof检查一个对象是否实现了某个特定的接口：
<code>if(x instanceof Concept){<br> ...<br>}</code> 另外，与可以建立类的继承关系一样，「接口也可以被继承」：
<code>public interface Concept1 {<br> void idea1();<br> void idea2();<br>}<br><br>-------------------------------------------<br> <br>public interface Concept2 extends Concept1{<br> double idea3();<br>}</code> 当然，读到这里大家可能依然无法理解，既然有了抽象类，为什么 Java 程序设计语言还要不辞辛苦地引入接口这个概念？
很重磅！因为「一个类可以实现多个接口，但是一个类只能继承一个父类」。正是接口的出现打破了 Java 这种单继承的局限，为定义类的行为提供了极大的灵活性。
<code>class Implementation implements Concept1, Concept2 // OK</code>
有一条实际经验：在合理的范围内尽可能地抽象。显然，接口比抽象类还要抽象。因此，一般更倾向使用接口而不是抽象类。
上文提过一嘴，「在 Java 8 中，允许在接口中增加静态方法和默认方法」。理论上讲，没有任何理由认为这是不合法的，只是这有违于将接口作为抽象规范的初衷。举个例子：
<code>public interface Concept {<br> // 静态方法<br> public static void get(String name){<br> System.out.println("hello " + name);<br> }<br> // 默认方法<br> default void idea1(){<br> System.out.println("this is idea1");<br> };<br>}</code> 用 default 修饰符标记的方法就是默认方法，这样子类就不需要去实现这个方法了。
不过，引入默认方法后，就出现了一个「默认方法冲突」的问题。如果先在一个接口 A 中将一个方法 idea 定义为默认方法， 然后又在另一个接口 B 或者超类 C 中定义了同样的方法 idea，然后类 D 实现了这两个接口 A 和 B（或超类 C）。于是类 D 中就有了方法 idea 的两个默认实现，出现了冲突，为此，Java 制定了一套规则来解决这个二义性问题：
1 ) 「超类优先」。如果超类提供了一个具体方法，接口中的同名且有相同参数类型的默认方法会被忽略。
2 ) 「接口冲突」。如果一个父类接口提供了一个默认方法，另一个父类接口也提供了一个同名而且参数类型相同的方法，子类必须覆盖这个方法来解决冲突。例如：
<code>interface A {<br> default void idea(){<br> System.out.println("this is A");<br> }<br>}<br><br>interface B {<br> default void idea(){<br> System.out.println("this is B");<br> }<br>}<br><br>// 需要在 D 类中覆盖 idea 方法<br>class D implements A, B{<br> public void getName(){<br> System.out.println("this is D");<br> }<br>}</code> 现在假设 B接口没有为 idea 提供默认实现：
<code>interface B {<br> void idea();<br>}</code> 那么 D 类会直接从 A 接口继承默认方法吗？这好像挺有道理， 不过，Java 设计者更强调一致性。两个接口如何冲突并不重要，「只要有一个接口提供了一个默认实现，编译器就会报告错误， 我们就必须解决这个二义性」。
当然，如果两个接口都没有为共享方法提供默认实现， 那么就与 Java 8 之前的情况一样，这里不存在冲突。
在我自己早期学习编程的时候，对接口存在的意义实在困惑，我自己乱写代码的时候基本上不可能意识到需要去写接口，不知道接口到底有什么用，为什么要定义接口，感觉定义接口只是提前做了个多余的工作。
其实不是，定义接口并非多余，「接口是用来提供公用的方法，规定子类的行为的」。举个例子，让大家直观的感受下接口的作用：
比如有个网站， 需要保存不同客户的信息， 有些客户从 Web 网站来， 有些客户从手机客户端来， 有些客户直接从后台管理系统录入。假设不同来源的客户有不同的处理业务流程， 这个时候我们定义接口来提供一个保存客户信息的方法，然后不同的平台实现我们这个保存客户信息的接口，以后保存客户信息的话， 我们只需要知道这个接口就可以了，具体调用的方法被封装成了黑盒子，这也就是 Java 的多态的体现，「接口帮助我们对这些有相同功能的方法做了统一管理」。
以上是Java中介面的作用是什麼？的詳細內容。更多資訊請關注PHP中文網其他相關文章！
