归纳Java中的Interface(接口)

 相对abstract class(抽象类)来讲，interface则造出了“完全抽象的class”，丝毫不带半点实现的内容。且interface中的所有methods都是虚的空的，当然，编译器也强迫你这样做。看下面事例：

       interface A{

              void x();// 这里不需写访问权限，x() 就自动成为了public void x()

              String Hello();

}

interface中的方法无需声明，都会自动设为了public。

当然，interface中的数据成员也变为了public,static,final。

看例子：

class B implements A{

       String str="Hello";// 这里的str 很自然的变成了public static final int str;

       public void x(){

       //……//

       }

       public String Hello(){

              return str;

       }

}

要注意,当某个类（like class B）实现了一个接口时，一定要把它实现的methods(函数)标明为 public，否则编译器不会让你好过。

 

以上只是interface的普通用法罢了，更让人兴奋的是：它可以让你实现原本以为java中没有的“多重继承”。即，你可以是个A，也可以是个B和C。看下面：

class father{}

interface Human{}

interface Boy{}

 

class Me extends father implements Human,Boy{}

 

呵呵，你们看到了，如语义，爸爸正继承(extends)一个，但我的身份却可以是“人类(human)”或者“男孩(boy)”。同样， 在 java 中，只能继承一个一般的Class(non-interface 即非接口类) ，但你却可以继承多个interface,也可以说“ interface 让你拥有多个身份”。这当然更利于 多态的应用咯。

还有，interface也是可以继承其它类的，但，只能是继承另一个接口。如以下：

 

class  A{}
abstract   class  B{}
interface  C{}
 
// !interface D extends A{}
// !interface D extends B{}
interface  D  extends  C{} // 看到吧，接口只能继承接口，继承其它的话，编译器回生气哟
 
然后呢，咱们再看一个比上面复杂一点的例子，说明了你不能胡乱的把两个接口同时实现：
interface  A{ void  a();}
interface  B{ void  b();}
 
class  Xa{
        public   void  a(){}
}
class  Xb{
        public   int  b(){ return   53 ;}
}
 
class  Hero  extends  Xa  implements  A,B{
        public   void  b(){}
// 大家注意，为什么这儿实现了 A和B 两个interface却只实现了b()一个接口呢？后面分解
}
 
// !class ErrTest extends Xb implements B{} // 这为什么报告错误呢？后面分解
 
public   class  Test {
        static   void  mA(A a){ // 这儿之所以可以用a来调用是因为，下面会进行向上转型，
                                    // A的derived class reference传到这里，当然可以使用，下同。
              a.a();
       }
        static   void  mB(B b){
              b.b();
       }
       
        public   static   void  main(String[] args) {
              Hero h = new  Hero();
              
              mA(h); // 向上转型，因为上面接参的是Hero的base class
              mB(h);
       }
} // /:~

好了，例子看完了，下面来解释上面的几个现象：

NO1.class Hero为什么实现了 A和B 两个interface却只实现了b()一个接口呢？因为它还同时继承了一个Xa类，而Xa中恰好又一个一模一样的void a(),所以， 在继承的同时，“爸爸替儿子”自动的实现了 a()，不用“儿子”亲自动手。

但是注意， 必须要是完全相同才行！（ 即需要同参数列表、同返回值），否则就会？看下面：

NO2. ErrTest不能再写下去是因为， 它所继承的 B 类的void a() 与它所实现的Xb 接口中的int a() 产生冲突。 两者名称相同，但是返回值不一样，导致编译器不知道该使用哪一个或者应该重写等，所以会报出错误。这就是冲突。

所以，须提醒的是： 尽量不要结合含同名参数的 interface 等，或者就干脆不要写同名的函数。

 

Interface还有一重要功能，平常不为人所用的： 产生常量群！！由于interface中的数据成员会自动成为public static final，所以……如下：

public   interface  Months{
               int  
JANURAUY = 1 , // 再次说明，常量都要全部用大写，语义间用下划线分开如： VAL_XX
                     FEBRUARY = 2 ,
                     MARCH = 3 ;
}

       然后要用的话，就直接 Months. JANURAUY ＊10类似的直接用就行了！完全OK！！超级好用！！

提醒：interface的常量群众的数据成员，因为是static静态的，所以当你首次使用这个常量群时，就会自动初始化里面的数据，不管你使用多少次它的数值都不会再变了。如下：

public interface Vals{

       int VAL_A=(int)(Math.random()*10);

}

我们看到，VAL_A是由随机数得值的，但当你第一次使用它时，VAL_A被赋予了一个随机数3.14，但以后不管你用多少次，都只是同一个数3.14。

 

然后呢， interface 可以互相嵌套，既可以嵌在class中，也可以嵌在另一个interface中。

Interface的嵌套可以发展出很多有趣的性质来，但是内容过多，一时间无法全部写下，so就此写一小点吧，需要用时再做深究。

“ 当某一个 interface 嵌套到了另一个interface 中时，则它一定会变成public ，无法标记为private”。

“ 当你实现某个 interface 时，根本无须实现嵌套在它里面的Other interfaces”

此外，“ private interface 是无法在它所定义的class 之外被发现的”。

 

好了，Interface（接口）就想到这里了。

以后还会陆续的作总结。