Java接口实现

接口是什么，它的作用是什么？首先，Java只能实现单继承，而有时候实际需要要求我们实现多继承，因此，接口就是为了实现多继承而开发出来的，并且接口支持程序在运行时动态地调用方法，它使得方法的声明和实现分隔开。

概述：
（1）声明接口；
（2）定义接口的实现类；
（3）使用接口；

一、接口的定义：

接口，由全局常量和公共的抽象方法组成的特殊类，是对抽象类的进一步抽象。

1.接口的声明格式：

interface 接口名称{
	全局常量声明;
	抽象方法声明;
}

接口中的方法声明只能写成抽象方法的形式，即不能带有方法体。在接口中，若没有显式声明修饰符，那么定义常量的修饰符默认为“public static final”，并且，定义方法的修饰符默认为“public abstract”。
接口中的抽象方法由接口的实现类来进行实现，即，在实现类中，接口的所有方法的方法体必须补充完整，并且方法的修饰符必须使用“public”来修饰，然后这些实现方法可以按照实际情况具有各自完全不同的行为功能。

接口与抽象类的比较：
关键字不同：接口的关键字为“interface”，抽象类的关键字为“abstract”
方法形式不同：接口中的方法只能是没有带方法体的抽象方法，抽象类中的方法既可以是抽象方法，也可以是带有方法体的普通方法；
属性不同：接口中的属性只能是常量，抽象方法中的属性没有限制；
使用不同：当各子类都存在一个共同的方法特征，但各自的具体实现又不太一样时，常使用接口。

接口与抽象类的结合使用：

抽象类实现接口时，接口中的抽象方法可以全部实现，也可以部分实现，甚至都不实现，并且这些未被实现的接口方法不需要在抽象类中重新显式声明为抽象方法，但是抽象类的子类必须全部实现抽象类中没有实现的抽象方法，以及来自接口而未在抽象类中实现的方法。

2.实现接口的类——实现类的声明格式：

public class 类名 implements 接口名{
	//方法实现
}

代码举例：

//接口
//InterfaceA.java
public interface InterfaceA{
	public void start();//抽象方法声明
	public void stop();//抽象方法声明
	
}

//实现类
//MovingDisk.java
public class MovingDisk implements InterfaceA{
	//方法实现
	public void start(){
		System.out.println("开始");
	}
	public void stop(){
		System.out.println("结束");
	}
}

//测试类
//Test.java
public class Test{
	public static void main(String[] args){
		InterfaceA a1=new MovingDisk();//将移动硬盘插入到接口A
		a1.start();//开启移动硬盘
		a1.stop();//关闭移动硬盘
	}
}

一个类可以实现多个接口，但只能继承一个父类（单继承）。

//实现多个接口
public class 类名 implements 接口1,接口2,接口3{
	//接口中的方法实现
}

当实现多个接口时，注意必须实现每一个接口所声明的方法。接口作为类型可以声明一个对象的引用变量，实现接口的类实例化后，其对象的引用可以保存在这个变量中，在通过引用变量访问方法。实际将调用哪个方法，将根据实际创建出来的对象调用相对应的实现方法（此处表现出程序通过接口找到方法的多态性）。在实现对象时，有必要时需要做接口转换，
假设b对象都实现了接口1和接口2，则可以将b对象进行接口转换与实现，将其转换后的接口与实现赋予另一个对象

//a1接收b对象转换后的接口1与实现
接口1 a1=(接口1) b;
a1.接口1的方法;
//a2接收b对象转换后的接口2与方法实现
接口2 a2=(接口2)b;
a2.接口2的方法;

子类同时继承抽象类和实现接口，代码举例

//Test.java
//接口A
interface A{
	public String name="nacy";//定义全局变量
	public void print();//定义抽象方法
}
//抽象类B
abstract class B{
	public abstract void say();
}
//子类同时实现接口，覆写抽象类B的抽象方法
class Child extends B implements A{
	//覆写抽象类B中的抽象方法
	public void say(){
		System.out.println("Hello");
	}
	//覆写接口A中的抽象方法
	public void print(){
	Systeem.out.println("Name:"+name);
	}
}
public class Test{
	public static void main(String [] args){
		Child c=new Child();//实例化子类对象
		c.say();//调用被覆盖过的方法
		c.print();//调用被覆写过的方法
	}
}

抽象类实现接口：

interface A{
	public String name="nacy";//定义全局变量
	public void print();//定义抽象方法
}

//抽象类B,实现接口
abstract class B implements A{
	public abstract void say();//此时抽象类中存在两个抽象方法：print()和say()
}

//子类继承抽象类B
class Child extends B {
	//覆写抽象类B中的抽象方法
	public void say(){
		System.out.println("Hello");
	}
	//覆写抽象类B中的抽象方法
	public void print(){
	Systeem.out.println("Name:"+name);
	}
}
public class Test{
	public static void main(String [] args){
		Child c=new Child();//实例化子类对象
		c.say();//调用被覆盖过的方法
		c.print();//调用被覆写过的方法
	}
}

在Java中，允许一个接口继承多个接口，允许抽象类继承接口，但不允许接口继承抽象类。注意，不要混淆子类继承接口（implements）、子类继承父类（extends）、子接口继承父接口（extends）的关键字。

单个接口可以同时继承多个父接口：

//接口继承多个父接口
public  interface 子接口名 extends 接口1,接口2,接口3{
	//接口中的方法实现
}

接口的多继承：

interface A{
	public String name="A";
	public void printA();
}
interface B{
	public void printB();
}

//定义接口C，同时继承接口A和B
interface C extends A,B{
	public void printC();
}

//子类实现接口C，并覆写所有接口的抽象方法
class Child implements C{
	public void printA(){System.out.println("A");}
	public void printB(){System.out.println("B");}
	public void printC(){System.out.println("C");}
}
public class Test{
	public static void main(String[] args){
		Child c=new Child();//实例化子类对象
		c.printA();//调用方法
		c.printB();
		c.printC();
	}
}

参考文献：
《Java开发实战经典第2版》李兴华
《Java程序设计任务驱动式教程》北京航空航天大学出版社
《Java学习笔记》良葛格