Java里的接口的interface 简单介绍.

这是写给我自己和我这种初学者看的.

Java作为1个强面向对象语言, 基本上所有东西(成员和方法)都是写在class(类)里面的.

但是也存在一种与class平行的东西, 它就是interface , 中文译成接口. 本屌能力有限在这里这能写写Interface的一些语法规则与存在意义.

一, 什么是接口

Java里的接口, 就是抽象方法和常量值的集合.

这里的定义相当表面, 就如java里的类是成员和方法的集合一样.

作为1个初学者, 可以简单理解为接口就是一种特殊的抽象类. 区别下面会详细提到.

二, Java里接口的定义和语法

interface 的定义跟java有点类似. 大概如下:

[public] interace interface_name [extends <Superinterface_list>]{

//public static final members

.....................

//public abstract methods

.......

}

下面是1个简单的例子:

interface It_1{ int i = 10;  //public static final//int j;   //error all the members in a interface must be a const member //& need assignment//public abstract It_1();   //error,  must without a constructorvoid print(); //public abstract
}

上面就简单定义了一个接口It_1. 接下来讲下接口定义的一些关键点:

2.1 关于接口前面的修饰符(这里只讨论外部接口)

外部interface前面的修饰符有两种:

2.1.1 public修饰接口

接口可以用public修饰, 但是这个接口必须定义在同名字的java文件内. 这种情况下此接口就是所谓的公共接口, 可以被所有类访问.

这也是interface最常见的用法.

2.1.2 没有任何修饰词修饰接口

如果1个接口不是在同名字的java文件内定义的. 那么这个接口前面不能带有任何权限修饰符, 就如上面的例子. 关键字前面没有权限修饰符.

如果架上public 则通不过编译.

这种情况下, 这个接口只能被同1个包内的类访问. 其他类不能访问.

2.1.3 不能用protected ,private 来修饰外部接口

跟外部类一样, 外部接口不能private 和 protected 来修饰.

2.1 接口里所有成员都是公共静态常变量成员.

也就是说接口里所有成员都是有个修饰组合: public static final.

代表了这个成员首先是公共的(所有类都可以访问), 静态的(只属于接口本身), 而且是个常变量(只能而且必须赋值一次).

这个组合可以被省略.

例如上面例子中的

int i = 10; 就相当于 public static final int i =10;

但是你写成

static final int i =10;

final int i = 10;

都是可以通过编译的, 但是i这个成员实际上还是 public static final的, 性质没变.

但是不能用protected 或 private 来修饰成员, 否则编译失败.

2.2 接口里所有方法都是公共抽象方法

也就是说接口里的方法都有个修饰词组合: public abstract

跟接口方法一样, 这两个修饰词也可以省略不写.

既然是抽象方法, 则不能包含方法体.

而且接口里不允许存在非抽象的方法, 这个也是接口和抽象类的明显区别之一.

2.3 接口里不能定义构造方法

即使这个构造方法是抽象的...

三, 接口的实现和继承

由于接口不是类, 所以接口没有实例化这个概念. 而且上面提到过接口类似1个抽象类.

而1个接口是可以继承另1个接口的(extends)

但是java里1个类也不能继承1个接口, 而有1个类似继承的概念, 就叫做实现( implements)

3.1 类可以实现接口

看下面的例子:

class It_class1 implements It_1{  //implement an interfacevoid f(){//i = 10;  error cannot do assignment for a const memberint j = this.i;}//void print(){  the signal of authority cannot smaller than super class's(interface)public void print(){ // overwrite an the abstract method.}
}

这个类就实现了上面的接口It_1. 接下来有几点要注意的.

3.1.1 1个类要实现1个接口, 关键字是implements 而不是extends

extends是继承的关键字, 而1个类是不能继承1个接口的.

3.1.2 类里面不能为接口的成员赋值

类继承1个接口的话, 可以使用接口的成员, 但是不能为它们赋值, 因为接口的成员都是常量.

3.1.3 如果1个非抽象类继承1个接口, 则必须重写接口里的所有方法.

原因也很简单, 因为接口的方法都是抽象的, 跟1个非抽象类继承1个抽象类一样, 都必须重写继承的所有方法. 非抽象类不允许有抽象方法.

3.2 接口的实现(implement)可以多态

也就是说虽然接口不能被实例化, 但是1个接口的引用变量可以指向实现它的类的1个对象.

跟继承的多态类似

下面例子:

public class Interface_1{public static void f(){It_1 a = new It_class1(); // Polya.print();}
}

看f()函数, 它定义了 1个接口的引用a, 但是指向了1个类的对象(前提是这个类实现該接口)

并调用了类重写后的方法.

3.3 接口可以继承接口

类可以继承类, 而接口也可以继承另1个接口.

下面例子:

package Interface_kng.Extend;interface Itf_1{int i = 1;void f();
}interface Itf_3 extends Itf_1{int j = 3;
}class Itf_class1 implements Itf_3{public void f(){ //overwriteSystem.out.printf("i is %d, j is %d\n", this.i, this.j);}
}public class Interface_3{public static void f(){Itf_class1  a = new Itf_class1();a.f();}
}

上面定义了2个接口, 其中Itf_3 继承了 Itf_1. 所有Itf_3 具有Itf_1的所有成员和方法.

后面类 Itf_class1 实现了接口Itf_3, 并重写了Itf_3继承自 Itf_1的方法f(), 输出了接口的两个成员值.

3.4 1个接口可以同时继承多个接口

跟类的单继承不同, 接口的继承可以是多继承.

看回本文第二节的接口语法定义, 后面的extends 跟的是1个list. 也就暗示了这可能是1个多继承.

下面例子:

interface Itf_1{int i = 1;void f();
}interface Itf_2{int k = 2;void g();
}interface Itf_3 extends Itf_1, Itf_2{int j = 3;
}class Itf_class2 implements Itf_3{public void f(){ //overwriteSystem.out.printf("i is %d, k is %d, j is %d\n", this.i, this.k, this.j);}public void g(){}
}public class Interface_3{public static void f(){Itf_class2  a = new Itf_class2();a.f();}
}

上面的接口Itf_3 同时继承了接口Itf_1 和 Itf_2. 所以Itf_3 同时具有了两者的成员和方法

接着非抽象了类 Itf_class2 实现了Itf_3, 并重写了所有接口方法.

接口的多继承有时也会产生冲突. 下面有两种情况要注意的:

3.2.1 假如1个接口A 继承另外两个接口B和C, 但是接口B,C 有相同名字的成员i

这种情况并不影响多继承, 但是当1个类实现了接口A时, 使用成员i时就不能用this.i了.

因为编译器会告诉你成员混扰. 需要告诉编译器你想调用那个成员, 毕竟这个成员是静态的, 前面可以加接口名字前缀.

例子:

interface Itf_1{int i = 1;void f();
}interface Itf_2{String i = "abc";int k = 2;void g();
}interface Itf_3 extends Itf_1, Itf_2{int j = 3;
}class Itf_class2 implements Itf_3{public void f(){ //overwriteSystem.out.printf("i1 is %d, i2 is %s, k is %d, j is %d\n", Itf_1.i, Itf_2.i, this.k, this.j);}    public void g(){}
}

例如上面的成员i, 如果在类中直接调用this.i, 编译失败..

3.2.1 假如1个接口A 继承另外两个接口B和C, 但是接口B,C 有相同名字的方法f().

这里还要分两种情况

假如这两个方法具有相同的返回类型.

这样的话则不影响继承. 在实现接口A时直接重写一次f() 就ok了.

编译器会将两个同名方法视为1个方法:

package Interface_kng.Extend;interface Itf_1{int i = 1;void f();
}interface Itf_2{String i = "abc";int k = 2;  //same name with Itf_1void f();   //same name with Itf_1void g();
}interface Itf_3 extends Itf_1, Itf_2{int j = 3;
}class Itf_class2 implements Itf_3{public void f(){ //overwriteSystem.out.printf("i1 is %d, i2 is %s, k is %d, j is %d\n", Itf_1.i, Itf_2.i, this.k, this.j);}    public void g(){}
}

假如这两个方法具有不同的返回类型.

这种情况下就悲剧了, 一个非抽象类无法实现该接口

例如:

interface Itf_1{int i = 1;void f();
}interface Itf_2{String i = "abc";int k = 2;  //same name with Itf_1int f();   //same name with Itf_1, but diff return typevoid g();
}

原因也很简单, 因为1个非抽象类无法同时重写这两个方法.

1个类中不允许有两个方法相同名字相同参数而返回值不同啊.

假如在工作中遇到这种情况怎么办? 除了重构.. 个人建议只能分别用两个类来实现两个接口...

所以在编程中, 为接口的成员和方法命名时最好加上接口的标记.. 避免将来可能发生的冲突...

3.5 1个类可以同时实现多个接口.

这个不难理解, 跟上面那点类似, 不过也可能会出现上面提到的冲突..

interface Itf_1{int i = 1;void f();
}interface Itf_2{String i = "abc";int k = 2;  //same name with Itf_1void f();   //same name with Itf_1void g();
}class Itf_class1 implements Itf_1, Itf_2{public void f(){ //overwriteSystem.out.printf("i1 is %d, i2 is %s, k is %d", Itf_1.i, Itf_2.i, this.k);}    public void g(){}
}

3.6 1个类可以继承另一个类的同时实现1个或多个接口.

这个也不难理解.

但是要把 extends 写在前面, implements 写在下面

语法:

class Class_nameextends Superclass_name implements <Superinterface_list>{

}

个人建议, 小心使用, 因为如果超类也实现了1个或多个相同的接口时就可能有冲突了..

四, Java接口的功能和意义

说道这个, 很多java教材介绍接口时对会提到电脑主板内存插槽和内存金手指的例子...

但是本人觉得这个例子不是很能体现java接口的意义

本人觉得, java里的接口更像是1个功能包或插件.

而java的类实现1个接口就相当于装备上了这个功能包或插件, 从而具有了这个功能包和插件的功能..

接下来还是引用权威吧..

1. 通过接口可以实验不相关类的相同行为.

例如 java规定所有可以完成自我复制功能的类都必需实现java.lang.Colneable 接口.

而这个接口是空的. 没有任何内容, 只是起1个标记作用

2. 接口提供了不同对象进行协作的平台

例如事件处理

3. 接口可以实现多继承, 一定程度上弥补了java类只能单继承的缺点.

4. 接口是我们了解1个类的功能的重要途径

例如1个类的定义代码很复杂, 而我们可以观察它实现了哪些接口, 大概估出这个类的作用.

上面的描述并不很清楚.

接口的意义请参考另一篇博文
http://blog.csdn.net/nvd11/article/details/41129935