Java里的接口的interface 简单介绍.(一)

2014-11-24 02:50:36 · 作者: · 浏览: 3

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


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

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



一, 什么是接口

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


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

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




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

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

[public] interace interface_name [extends ]{

//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个多继承.

下面例子: