当一个抽象类中的方法都是抽象的时候，这时可以将该抽象类用
另一种形式定义和表示，就是 接口 interface
例如：
abstract class AbsDemo
{
abstract void show1();
abstract void show2();
}
定义接口使用的关键字不是class，是interface
对于接口当中常见的成员：而且这些成员都有固定的修饰符。
全局常量: public static final
抽象方法。public abstract
由此得出结论，接口中的成员都是公共的权限. 而且这些修饰符可以不写，但是只要在接口中，就会默认带有这些关键字。
注意：最好还是都写上，增加阅读性
interface Demo
{
public static final int NUM = 4;
public abstract void show1();
public abstract void show2();
}
可以写成：
interface Demo
{
int NUM = 4;
void show1();
void show2();
}
**类与类之间是继承关系，类与接口直接是实现关系。 **
接口不可以实例化。
实现接口的关键字：implements
只能由实现了接口的子类并覆盖了接口中所有的抽象方法后，该子类才可以实例化。
否则，这个子类就是一个抽象类。
class DemoImpl implements /*实现*/Demo
{
public void show1()
{}
public void show2()
{}
}
在java中不直接支持多继承，因为会出现调用的不确定性。
所以java将多继承机制进行改良，在java中变成了多实现。
一个类可以实现多个接口。
因为接口没有方法体，所以即使不同的接口中有同名的方法，也不会有问题。
但是如果不同的接口中有同名方法(参数列表相同的情况下)，但是返回值不同，这是不被允许的，会报错。
interface A
{
public void show();
}
interface Z
{
// public int show();//这是不允许的
public int add(int a,int b);
public void show();
}
class Test implements A,Z//多实现,
{
public int add(int a,int b)
{
return a+b+3;
}
//这里支持方法的重载
/*public int add(int a,int b，int c)
{
return a+b+3;
}
*/
public void show(){}
}
一个类在继承另一个类的同时，还可以实现多个接口。
class Q
{
public void method()
{}
}
//抽象类也可以继承类(或抽象类)和实现接口，而且可以不实现其中的方法，(即没有方法体)
/*abstract*/ class Test2 extends Q implements A,Z//这里的A和Z指上面代码的类
{
}
接口的出现避免了单继承的局限性。
接口与接口之间是继承关系，而且接口可以多继承
interface CC
{
void show();
}
interface MM
{
void method();
}
interface QQ extends CC,MM//接口与接口之间是继承关系，而且接口可以多继承。
{
void function();
}
class WW implements QQ
{
//覆盖3个方法。
public void show(){}
public void method(){}
public void function(){}
}
抽象类和接口的异同点：
相同点：
都是不断向上抽取而来的。
不同点：
1，抽象类需要被继承，而且只能单继承。
接口需要被实现，而且可以多实现。
2，抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法。
接口中只能定义抽象方法，必须由子类去实现。
3，抽象类的继承，是is a关系，在定义该体系的基本共性内容。
接口的实现是** like a** 关系，在定义体系额外功能。
举例：
犬按功能分：有导盲犬，搜爆犬。
abstract class 犬
{
abstract void 吼叫();
}
//abstract class 导盲//继承无法实现多继承，所以不能这么写
interface 导盲//之所以写一个导盲的接口，而不直接在导盲犬类直接写个导盲功能，是应为这样不具备扩展性，具备导盲功能的不一定只是导盲犬。
{
abstract void 导盲();
}
class 导盲犬 extends 犬 implements 导盲
{
public void 吼叫()
{
}
public void 导盲(){}
}
特点：
1.接口是对外暴露的规则
2.接口是程序的功能扩展
3.接口的出现降低耦合性
4.接口可以用来多实现
应用举例说明：
/*
笔记本电脑使用。
为了扩展笔记本的功能，但日后出现什么功能设备不知道。
定义一个规则，只要日后出现的设备都符合这个规则就可以了。
规则在java中就是接口。
*/
interface USB// 暴露的规则。
{
public void open();
public void close();
}
class BookPC
{
public static void main(String[] args)
{
useUSB(new UPan());//功能扩展了。
useUSB(new UsbMouse());
}
//使用规则。
public static void useUSB(USB u)//接口类型的引用，用于接收(指向)接口的子类对象。//USB u= new UPan();
{
if(u!=null)
{
u.open();
u.close();
}
}
}
//--------------------------------------------
//一年后。买了一个鼠标和U盘
//实现规则。
//这些设备和电脑的耦合性降低了。
class UPan implements USB
{
public void open()
{
System.out.println("upan open");
}
public void close()
{
System.out.println("upan close");
}
}
class UsbMouse implements USB
{
public void open()
{
System.out.println("UsbMouse open");
}
public void close()
{
System.out.println("UsbMouse close");
}
}
