接口和接口实现类，接口与抽象类

Java不支持多重继承，即一个子类只允许拥有一个父类。为了弥补这个不足，Java中的接口可以实现多重继承，一个类可以实现多个接口。

定义和实现接口

接口的定义包括接口声明和接口体两部分。接口体包括属性常量和抽象方法。

[public] interface 接口名 {
	属性常量
	...
	抽象方法
	...
	
}

interface是声明一个接口的关键字，在Java中，接口的属性只允许为静态常量，即static或者final类型，接口中的方法都是未定义的抽象方法。接口中无论是属性还是方法都默认为public类型。
用implements表示实现一个接口，在实现类中要必须实现接口中定义的所有方法并且可以使用接口里面定义的属性常量。此外，一个类可以实现多个接口。
来一个例子：

package Liu;
interface Action {
	String name = "Liu Yankee";		//默认是public static final类型的属性常量
	public void walk();
	public void run();
}
class Person implements Action {
	public Person() {
		
	}
	private int age;		//定义自己的私有属性
	private int birthDate;
	//实现接口的抽象方法walk()
	public void walk() {
		System.out.println(name + " is walking!");
	}
	//实现接口的抽象方法run()
	public void run() {
		System.out.println(name + " is running!");
	}
	//定义与接口无关的与类相关的方法
	public void love() {
		System.out.println(name + "can fall in love with a beautiful girl!");
	}
}
//测试类
public class text5 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Action  man = new Person();
		man.run();
		man.walk();
	}

}

1）接口是一个引用类型
2）接口是某种特征的约定
3）接口里面的所有方法自动为public abstract类型
4）通过接口可以实现不相关类的相同行为而不需要考虑这些类之间的层次关系，从而在一定意义上实现了多重继承
5）通过接口可以指明多个类需要实现的方法
6）通过接口可以了解对象的交互界面，而不需要了解对象所对应的类

接口的特性

首先必须要了解接口不同于类的一些特性
1）接口中的方法可以有参数列表和返回类型，但是不能有任何方法体实现
2）接口中可以包含属性，但是会被隐式声明为static 和final类型，存储在该接口的静态存储区里面，而不属于该接口
3）接口中的方法被声明为public或者不声明，但结果都会按照public类型处理
4）如果没有实现接口中的所有方法那么创建的仍然是一个接口，即接口可以继承接口(使用extends关键字)，在继承时，父接口传递给子接口只是方法说明，而不是具体实现
5）一个接口可以有一个以上的父接口，一个类可以在继承父类的同时实现多个接口，即实现多重继承

接口与抽象类的区别

抽象类作为所有子类的标准有点类似于模板，所有子类只能在其格式范围内修改并补充。Java接口和Java抽象类代表的是抽象类型，是抽象层的具体实现。面向对象编程，如果要提高程序的复用率，增加程序的可维护性，可扩展性，就必须正确的使用接口和抽象类作为系统结构层次上的顶层，进行面向对象或者面向接口的编程。
（1）接口和抽象类的最大一个区别是：抽象类可以提供部分已经实现的方法，但是接口所有的方法都是抽象的

//使用接口计算长方体的面积
package Liu;
//定义一个接口
interface Fiure {
	double calculateArea();	//抽象方法calculateArea()
	void showArea();			//抽象方法showArea()
}
class Rectangular implements Fiure {
	private double length;		//私有属性
	private double width;		//私有属性
	//带参数的构造方法
	public Rectangular(double length, double width) {
		this.length = length;
		this.width = width;
	}
	//接口抽象方法实现
	public double calculateArea() {
		double area = this.length * this.width;
		return area;
	}
	//接口抽象方法实现
	public void showArea() {
		double Area = calculateArea();
		System.out.println("此图形的面积为：" + Area);
	}
}
//测试类
public class text6 {

	public static void main(String[] args) {
		//实现接口
		Fiure pFiure = new Rectangular(5.6, 6.9);
		pFiure.showArea();
	}

}
此图形的面积为：38.64

由程序可以知道，接口的方法在其实现类中必须全部被实现，否则无法成功通过编译

（2）抽象类作为公共的父类，为子类的扩展提供基础，包括属性和行为上的扩展。而接口不重视属性，只重视方法，使得子类可以自由的填补或者扩展接口所定义的方法
（3）一个抽象类的实现只能由这个抽象类的子类给出，实现抽象类以继承为基础，而一个类可以实现任意多个接口

package Liu;
//接口Useleg
interface Useleg {
	void run();
	void walk();
	
}
//接口Usemouth
interface Usemouth {
	void speak();
	void eat();
	
}
//接口Useear
interface Useear {
	void hearMusic();
	
}
//接口USeeye
interface Useeye {
	void seeFilm();
	
}
//Person类实现多个接口
class Person implements Useleg, Usemouth, Useear, Useeye {
	String name;
	int age;
	String address;
	String ID;
	public void run() {
		System.out.println("I am running!");
		
	}
	public void walk() {
		System.out.println("I am walking!");
		
	}
	public void speak() {
		System.out.println("I am speaking!");
		
	}
	public void eat() {
		System.out.println("I am eating!");
		
	}
	public void hearMusic() {
		System.out.println("I am listening to music!");
		
	}
	public void seeFilm() {
		System.out.println("I am seeing a film!");
		
	}
	
}
//测试类
public class text7 {

	public static void main(String[] args) {
		//实现Usemouth接口
		Usemouth person = new Person();
		person.eat();
		person.speak();

	}

}
I am eating!
I am speaking!

实现多个接口，每个接口名在implements关键字后面用逗号隔开，同时具有多个接口所定义的行为，而且必须实现所有抽象方法。
技巧：抽象类侧重属性，接口侧重方法，在实际编程中，可以将接口放在最底层，在抽象类中实现接口的各个方法，进而让子类继承实现。

定义接口interface
...
//抽象类实现接口
abstract class [类名] implements [接口名] {
	...
	
}
//子类继承抽象类
class [类名] extends [抽象类]