格式：
interface{}
接口中的成员修饰符是固定的：
1 成员变量：publica static final
2 成员函数：publica abstract
3 发现接口中的成员都是public的
当一个抽象类的方法都是抽象的时候，这时可以将
该抽象类用另一种形式定义和表示，就是 接口 。
定义接口使用的关键字不是class，是interface。
对于接口当中常见的成员：而且这些成员都有固定的修饰符
1 全局常量：public static final
2 抽象方法，public abstract
interface Demo{
public static final int NUM=4;
public abstract void show1();
public abstract void show2();
}
由此得出结论，接口中的成员都是公共的权限。
类与类之间是继承关系，类与接口之间是实现关系implements。
接口不可以实例化，只能由实现了接口的子类并覆盖了接口中所有的抽象方法后，该子类才可以实例化，否则，这个子类就是一个抽象化。
实现例子：
//定义接口
interface Demo{
public static final int NUM=4;
public abstract void show1();
public abstract void show2();
}
//实现接口的子类并覆盖接口中所有的抽象方法
class DemoImpl implements Demo{
public void show1()
{}
public void show2()
{}
}
//将子类实例化，并调用NUM
public class InterfaceDemo {
public static void main(String[] args) {
DemoImpl d=new DemoImpl();
System.out.println(d.NUM);
System.out.println(DemoImpl.NUM);
System.out.println(Demo.NUM);
}
}
接口的出现将“多继承”通过另外一种形式体现出来，即“多实现”。
在java中不直接支持多继承，因为会出现调用的不确定性。所以java将多继承机制进行改良，在java中变成了多实现。
一个类可以实现多个接口。
多实现例子：
interface A{
public void show();
}
interface Z{
public void show();
}
interface M{
public int add(int a,int b);
}
public class MoreIamplements implements A,Z,M//多实现
{
public void show(){
System.out.print(add(1,2));
}
public int add(int a,int b){
return a+b;
}
}
public class InterfaceDemo {
public static void main(String[] args) {
MoreIamplements m=new MoreIamplements();
m.show();
}
一个类在继承另一个类的同时，还可以实现多个接口。
一个类在继承另一个类的同时，还可以实现多个接口，接口的出现避免了单继承的局限性：
//接口A,M的代码同上
class Q{
public void method(){
System.out.println("继承");
}
}
public class MoreIamplements extends Q implements A,M//继承先增加功能，多实现再扩展其他功能
{
public void show(){
super.method();
System.out.println("实现");
}
public int add(int a,int b){
return a+b;
}
public class InterfaceDemo {
public static void main(String[] args) {
MoreIamplements m=new MoreIamplements();
m.show();
}
}
接口与接口之间可以继承，是继承关系，而且接口可以多继承。原理就是方法体是否有存在。
interface CC{
void show();
}
interface MM{
void show();
}
interface QQ extends CC,MM{
void function();
}
class WW implements QQ{
//因为接口都是抽象的，所以实现要覆盖三个方法。
public void show(){}
public void method(){}
public void function(){}
}
总结：
接口的特点：
1 接口是对外暴露的规则
2 接口是程序的功能扩展
3 接口的出现降低耦合性（联系性）
4 接口可以用来多实现
5 类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。
6 接口与接口之间可以有继承关系
接口与抽象类的异同点：
相同点：
都是不断向上抽取而来的。
不同点：
1 抽象类需要被继承，而且只能单继承。接口需要被实现，而且可以多实现
2 抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法。
3 抽象类的继承，是 is a关系，在定义该体系的基本共性内容。接口的实现是 like a关系，在定义额外功能。
abstract class 犬{//基本功能
abstract void 吼叫();
}
//abstract class 导盲//会导盲的不止有导盲犬
interface 导盲{//额外功能
abstract void 导盲();
}
class 导盲犬 extends 犬 implements 导盲{
public void 吼叫(){}
public void 导盲(){}
}
接口的应用：
以笔记本为例，为了扩展笔记本的功能，但日后出现什么功能设备不知道。
定义一个规则，只要日后出现的设备符合这个规则就可以了。
规则在java中就是接口。
interface USB{//暴露的规则
public void open();
public void close();
}
public class BookPC {
public static void main(String[] args) {
useUSB(new UPan());//功能扩展
}
//使用规则
public static void useUSB(USB u){//接口类型的引用，用于接收（或者说指向）接口的子类对象 //这里是多态（后面讲）的使用即USB u=new UPan();
u.open();
u.close();
}
}
//一年后买了个U盘 必须得符合规则
//实现规则
//这些设备和电脑的耦合性降低了
class UPan implements USB{//符合规则
public void open(){
System.out.println("upan open");
}
public void close(){
System.out.print("upan close");
}
}