玩转接口

玩转接口

一、 关键字interface定义接口

接口定义和类的定义类似，分为接口声明和接口体。

代码示例：

public interface Printable {
	public static final int MAX=100;//MAX成员变量被final修饰，则MAX为常量，访问权限一定为public;public static final可以全部省略
	public abstract void add();//无参的抽象函数，访问权限为public；可以省略public abstrate
	public abstract float sum(float x,float y);//有参的抽象函数访问权限为public；可以省略public abstrate

}

接口声明：
interface 接口名
与类不同的是，定义接口时使用关键字interface声明自己是一个接口。

代码示例：

interface Printable;//printable便是上面定义的接口名称

接口体：
接口体是常量（无变量）声明和抽象方法声明的组合。接口体中所有常量的访问权限一定都是public ，而且是static常量（代码中可以省略public static final修饰符），接口体中的方法虽然只有抽象方法，没有普通方法，但是abstract方法的访问权限全部为public（可以省略 public abstract修饰符）
下面展示 interface接口体：

public interface Printable{
public static final int MAX = 100;//等价写法：int MAX = 100;MAX为常量
public abstract void add();//无参抽象函数;等价写法 void add();
public abstract float sum(float x,float y);//有参抽象函数；等价写法 float sum(float x,float y);

二、实现接口

一个类需要在类声明中使用关键字 implements 声明该类实现一个或者多个接口:

类实现接口

一个类实现多个接口代码示例：

public class A implements Printable,Addable{
.....;
.....;
}

Animal的子类Dog实现Eatable和Sleepable接口代码示例：

public class Dog extends Animal implements Eatable,Sleepable{
.....;
.....;
}

重写接口中的方法

一个非抽象类实现了某个接口，那么这个类必须重写这个接口中的所有方法，所谓重写就是给抽象方法付诸具体的行为功能；因为接口中的方法一定是public abstract方法，所以重写方法时要去掉abstract修饰符、给出方法体，而且方法的访问权限一定要用public修饰（否则降低了访问权限，这是不允许的）。
用户自定义接口：由类和接口组成的Java源文件
自定义 Computable接口：

Computable.java

public interface Computable{
	public static final int MAX01 = 46;
	public abstract int f(int x);	//此方法为公有抽象方法

写一个 China类实现Computable接口：

China.java

public class China implements Computable{
	int number;
	@Override
	public int f(int x) {//重写Computable接口中的抽象函数，c此方法为public
		int sum=0;
		for(int i = 0;i<x;i++) {
			sum+=i;
		}
		return sum;
	}
}

写一个 Japan类实现Computable接口：

Japan.java

public class Japan implements Computable {
	int number;
	@Override
	public int f(int x) {//重写Computable接口中的f()方法
		return MAX01+x;
	}
}

丢出一个Test类，实现以上两个类包括其中的方法：

Test.java

public class Test{
	public static void main(String[] args){
		China zhang;//China类声明了zhang对象
		Japan henbin;//Japan类声明了benbin对象
		zhang = new China();//创建了zhang对象
		henbin = new Japan();//创建了henbin对象
		zhang.number = 32+Computable.MAX01;//Computable.MAX01用接口名访问接口的常量
		henbin.number = 14+Computable.MAX01;//同样使用接口名访问接口常量
		System.out.println("zhang的学号"+zhang.number+",zhang求和结果："+zhang.f(100));
		System.out.println("henbin的学号"+henbin.number+",henbin求和结果"+henbin.f(100));
	}

抽象类声明实现了一个接口，但不重写接口中的所有方法，抽象类既可以重写接口中的方法，也可以直接拥有接口中的方法：

代码示例：

interface Computable01{
	public static final int MAX = 100;
	public abstract void speak(String s);
	public abstract int f(int x);
	public abstract float g(float x, float y);
}

abstract class A implements Computable01{
	public  int f(int x){ //重写了f()方法
		int sum = 0;
		for(int i=1;i<=x;i++){
			sum+=i;
		}
		return sum;
	}
}

接口细节说明：

1、程序可以直接用接口名访问接口中的常量，一个类实现了接口，那么该类可以直接在类体中使用该接口中的常量。
2、有public修饰的interface是公有接口，可以被任何类实现；无public修饰的interface接口是友好接口，可以被与该接口同在一个包中的类实现
3、父类实现了某个接口，子类自然随着父类实现了该接口，那么子类就可以不必显式地使用关键字implements声明该接口
4、接口可以被继承，同类继承一样，使用extends关键字声明一个接口是另一个接口的子接口，由于接口中的方法和常量都是public，所以子接口将继承父类中的全部方法和常量。
5、Java接口都在包中，使用import语句既可以导入包中的类，也可以导入包中的接口。