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 constructor

void 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 interface

void f(){
//i = 10;  error cannot do assignment for a const member
int 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(); // Poly
a.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(){ //overwrite
System.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(){ //overwrite
System.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(){ //overwrite
System.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_1
void f();   //same name with Itf_1
void g();
}

interface Itf_3 extends Itf_1, Itf_2{
int j = 3;
}

class Itf_class2 implements Itf_3{
public void f(){ //overwrite
System.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_1
int f();   //same name with Itf_1, but diff return type
void 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_1
void f();   //same name with Itf_1
void g();
}

class Itf_class1 implements Itf_1, Itf_2{
public void f(){ //overwrite
System.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