第8章 接口與內隱類

　　 一. 接口

　　 1． 如果實現接口的class未實現接口中的所有函數，則這個class必須被聲明為abstractclass，而接口中未被實現的函數在這個class中為abstractclass。

　　 interface Interface{
　　 public void f();
　　 public void g();
　　 }
　　 abstract class First implements Interface{
　　 public void f(){}
　　 }
　　 class Second extends First{
　　 public void g(){}
　　 }
　　 public class ExplicitStatic{
　　 public static void main(String[] args){
　　 Interface f = new Second();
　　 f.f();
　　 f.g();
　　 }
　　 }
　　 2． 接口中的所有函數自動具有public訪問權限，所以實現某個接口時，必須將承襲自該接口的所有函數都定義為public

　　 interface MyInterface {
　　 public void f();
　　 void g();
　　 }
　　 class First implements MyInterface {
　　 public void f(){}
　　 //！void g(){}出錯，應定義為public
　　 }
　　 3． 接口中的數據成員自動成為static和final

　　 interface MyInterface{
　　 int i = 5;
　　 void f();
　　 void g();
　　 }
　　 class First implements MyInterface {
　　 public void f(){}
　　 public void g(){}
　　 }
　　 public class ExplicitStatic{
　　 public static void main(String[] args){
　　 MyInterface x = new First();
　　 // MyInterface的數據成員I為static，可直接調用
　　 System.out.println("MyInterface.i = " + MyInterface.i + " , x.i = " + x.i);
　　 // MyInterface的數據成員I為final，不能修改
　　 //x.i++;
　　 // MyInterface.i++;
　　 }
　　 }
　　 4． 多重繼承

　　 1) devricedclass可以同時繼承多個interface和一個abstract或concretebaseclass。如果同時繼承了baseclass和interface，那么要先寫下具象類的名稱，然后才是interfaces的名稱。

　　 2) 如果derivedclass所繼承的具象類具有與interfaces相同的函數，則可在derivedclass不實現那個函數。

　　 interface CanFight{
　　 void fight();
　　 }
　　 interface CanSwim{
　　 void swim();
　　 }
　　 class ActionCharacter{
　　 public void fight(){}
　　 }
　　 class Hero extends ActionCharacter
　　 implements CanFight, CanSwim{
　　 public void swim(){};
　　 }
　　 public class ExplicitStatic{
　　 static void f(CanFight x) { x.fight(); }
　　 static void s(CanSwim x) { x.swim(); }
　　 static void a(ActionCharacter x) { x.fight(); }
　　 static void h(Hero x){
　　 x.fight(); x.swim();
　　 }
　　 public static void main(String[] args){
　　 Hero h = new Hero();
　　 f(h); s(h); a(h); h(h);
　　 }
　　 }
　　 因為在ActionCharacterclass中有與接口CanFight完全相同的函數fight()，所以在Heroclass可以不實現fight()方法。當要調用x.fight()時，會調用ActionCharacterclass中的fight()函數。

　　 3) 接口的合并時的名稱沖突問題

　　 interface I1 { void f(); }
　　 interface I2 { int f(int i); }
　　 interface I3 { int f(); }
　　 class C { public int f() { return 1; } }
　　 class C2 implements I1, I2{
　　 public void f() {}
　　 public int f(int i) { return 1; }
　　 }
　　 class C3 extends C implements I2{
　　 public int f(int i) { return 1; }
　　 }
　　 class C4 extends C implements I3{
　　 public int f() { return 1; }
　　 }
　　 //class C5 extends C implements I1{}（a）

　　 //class C6 extends C implements I1{ public void f(){} }（b）

　　 interface I4 extends I1, I3{}//（c）

　　 class C7 implements I4{
　　 public void f() {}
　　 public int f() { return 1; }
　　 }
　　 （a）處代碼會產生以下錯誤： method f() in class C cannot implement method f() in interface I1 with different return type, was void。

　　 （b）處代碼也是錯誤的： method f() in class C6 cannot override method f() in class C with different return type, was int。由（b）處代碼也可看出，雖然你試圖實現接口I1中的函數，但由于extends C在前，所以編譯器會把C6中的函數看成是覆寫classC中的函數，而不是象你想象中的作為實現接口中的函數的函數。

　　 （c）處代碼在原書中（P253）說會出錯，但我在測試時并沒發生錯誤。但當你試圖通過C7來實現接口I4時，是無論如何也不可能編譯通過的。

　　 4) Java中唯一可以使用多重繼承的地方

　　 Java是不允許通過關鍵字extends來實現多重繼承的，但除了通過多重繼承來擴充接口除外。

　　 interface I1{
　　 void f1();
　　 }
　　 interface I2{
　　 void f2();
　　 }
　　 interface Ie1 extends I2{
　　 void fe1();
　　 }
　　 class Ce1 implements Ie1{
　　 public void f2() {}
　　 public void fe1() {}
　　 }
　　 interface Ie2 extends Ie1, I1{
　　 void fe2();
　　 }
　　 class Ce2 implements Ie2{
　　 public void fe2() {}
　　 public void f2() {}
　　 public void fe1() {}
　　 public void f1() {}
　　 }
　　 接口Ie2繼承了兩個接口。

　　 5． 嵌套的interfaces

　　 嵌套的interfaces可以在定義該內部接口的外部類（接口）之外被使用（但內隱類不行）。

　　 1) 當接口嵌套于class中

　　 a) 不論接口為public、friendly或private，都可被實現為public、friendly、private三種嵌套類。

　　 b) 被聲明為private的接口不能在class外被使用。

　　 class A{
　　 private interface B{
　　 void f();
　　 }
　　 public class BImp implements B{
　　 public void f() {}
　　 }
　　 private class BImp2 implements B{
　　 public void f() {}
　　 }
　　 public B getB() { return new BImp(); }
　　 private B dRef;
　　 public void recivedD(B d){
　　 dRef = d;
　　 dRef.f();;
　　 }
　　 }
　　 public class ExplicitStatic{
　　 public static void main(String[] args){
　　 A a = new A(); //（a）

　　 //A.B ab = a.getB();（b）

　　 //A.BImp = a.getB();（c）

　　 a.recivedD(a.getB());
　　 }
　　 }
　　 雖然Aclass含有接口，但它仍可被實例化，如（a）。

　　 由于接口B為private，所以在（b）處調用接口B時會出錯。但當把接口B聲明為public時，（b）將通過編譯。但（c）處依然會出錯，因為內隱類的作用域為定義該內隱類的外部類內（見內隱類）。

　　 2) 當接口嵌套于接口中

　　 1) 嵌套于接口中的接口自動為public，且只能為public。

　　 2) 當實現某個接口時，無需實現其中嵌套的接口。

　　 3) Private接口無法在其所定義的class之外被實現。