java中的接口

一、接口的基本概念

1、接口是一种特殊的类，是由全局变量和抽象方法组成。因此其格式为：

interface  接口名称{
     全局变量；
     抽象方法；
}

PS：在接口和接口的抽象方法中，不管写没写，接口中方法永远都是public。

2、示例代码：

interface A{
	public static final String NAME = "lkp";	//定义全局变量
	public abstract void print();		<span style="white-space:pre">	</span>//定义抽象方法
	public abstract String getInfo();		//定义抽象方法
}

红色的代码可以省略不写，简化为如下形式：

interface A{
	String NAME = "lkp";<span style="white-space:pre">			</span>//定义全局变量
	void print();				//定义抽象方法
	String getInfo();			//定义抽象方法
}

二、接口的使用

1、接口若要使用必须通过子类，子类通过implement实现接口，格式如下：

class 子类 implements 接口A，接口B，....{
	
}

很显然，一个类可以实现多个接口，解决了java中单继承的局限。

2、接口的实现，代码如下：

package lkp;

interface A{<span style="white-space:pre">						</span>//定义接口A
	public static final String  NAME = "lkp";<span style="white-space:pre">	</span>//全局变量
	public abstract void print();<span style="white-space:pre">			</span>//抽象方法
	public abstract String getInfo();<span style="white-space:pre">		</span>//抽象方法
}

interface B{<span style="white-space:pre">						</span>//定义接口B
	public abstract void say();<span style="white-space:pre">			</span>//抽象方法
}
class C implements A,B{<span style="white-space:pre">					</span>//定义一个类，实现接口A和B
	//覆写A接口的抽象方法print（）
	public void print(){
		System.out.println("覆写A接口的抽象方法print（）");
	}
	//覆写A接口的抽象方法getInfo（）
	public String getInfo(){
		return "覆写A接口的抽象方法getInfo（）";
	}
	//覆写B接口的抽象方法say（）
	public void say(){
		System.out.println("覆写B接口的抽象方法say（）");
	}
}

class Test{
	public static void main(String args[]){
		C c = new C();//实例化子类对象
		//调用被覆写过的方法
		c.print();
		System.out.println(c.getInfo());
		c.say();
	}
}

解释：一个子类实现多个接口，则必须把接口中的全部抽象方法都覆写

3、继承抽象类实现接口

格式如下：

class 子类 extends 抽象类 implements 接口A，接口B，....{
	
}

示例代码如下：

package lkp;

interface A{//定义接口A
	public static final String  NAME = "lkp";//全局变量
	public abstract void print();//抽象方法
	public abstract String getInfo();//抽象方法
}

interface B{//定义接口B
	public abstract void say();//抽象方法
}

abstract class D{//定义抽象类
	public abstract void talk();
}
class C extends D implements A,B{//定义一个类，实现接口A和B
	//覆写A接口的抽象方法print（）
	public void print(){
		System.out.println("覆写A接口的抽象方法print（）");
	}
	//覆写A接口的抽象方法getInfo（）
	public String getInfo(){
		return "覆写A接口的抽象方法getInfo（）";
	}
	//覆写B接口的抽象方法say（）
	public void say(){
		System.out.println("覆写B接口的抽象方法say（）");
	}
	//覆写抽象类D的抽象方法talk
	public void talk(){
		System.out.println("覆写抽象类D的抽象方法talk（）");
	}
}

class Test{
	public static void main(String args[]){
		C c = new C();//实例化子类对象
		//调用被覆写过的方法
		c.print();
		System.out.println(c.getInfo());
		c.say();
		c.talk();
	}
}

解释：抽象类和接口都有抽象方法，所有两者的抽象方法都要被覆写。

4、抽象类实现接口

package lkp;

interface A{//定义接口A
	public static final String  NAME = "lkp";//全局变量
	public abstract void print();//抽象方法
	public abstract String getInfo();//抽象方法
}

abstract class B implements A{//定义一个抽象类实现接口
	public abstract void say();
}

class C extends B{//定义一个类继承抽象类
	public void print(){
		System.out.println("覆写接口A的抽象方法print（）");
	}
	public String getInfo(){
		return "覆写接口A的抽象方法getInfo（）";
	}
	public void say(){
		System.out.println("覆写抽象类B的抽象方法say（）");
	}
}

class Test{
	public static void main(String args []){
		C c = new C();
		c.print();
		System.out.println(c.getInfo());
		c.say();
	}
}

5、接口的继承

java中一个接口是不允许继承抽象类的，但是允许一个接口继承多个接口。

package lkp;

interface A{//定义接口A
	public static final String  NAME = "lkp";//全局变量
	public abstract void print();//抽象方法

}
interface B{//定义接口B
	public abstract String getInfo();//抽象方法
}
interface C extends A,B{//定义接口C继承接口A和B
	public void say();
}

class D implements C{//定义一个类D实现接口C
	//覆写接口中的抽象方法
	public void print(){
		System.out.println("覆写接口A的抽象方法print（）");
	}
	public String getInfo(){
		return "覆写接口B的抽象方法getInfo（）";
	}
	public void say(){
		System.out.println("覆写接口C的抽象方法say（）");
	}
}

class Test{
	public static void main(String args []){
		D d = new D();
		d.print();
		System.out.println(d.getInfo());
		d.say();
	}
}