接口：
1、引出接口：发现没有继承关系的类也能共享行为；
2、接口是一种独立与类的新机制，它关注的是行为，设计上大仙有行为在多个没有继承关系的类之间共享，就把它抽取到接口中，而不是蟹岛父类中；
3、1）定义接口——关键字interface；
public interface Serviceable extends Changeable{
//属性---只能公共静态常量属性---就算不写这三个关键字，也是默认为这种情况
//这说明接口的关注点不在属性身上，而是在行为身上
// public static final int a = 100; 默认常量必须赋初值
// public static int b = 200; 三个关键字：public、static、final
// public int c = 300;
// int d = 400;
// 说明接口的关注点不在属性身上，关注的是行为；
构造——接口不能有构造
接口不能产生对象，而是申明对象；
（1 让类实现接口，而且是多实现；
（2 接口可以继承接口，而且是多继承；
行为——只能是公共的抽象方法，就算不写修饰符，也是默认这种情况；说明接口的专注点和丰富度是体现在行为上的；接口的意义就体现在：让没有继承关系的类共享这些行为，各有各的具体实现；
public abstract void turnupEnginee();
void changeOil();
在JDK1.7以上版本，允许接口拥有实现了的方法；
但必须使用default关键字修饰；
public default void test(){
}
2）类实现接口：
类实现接口：使用implements关键字，并且重写接口中的抽象方法，类可以多实现接口；
public interface Changeable {
public void changeOil();
}
如果一个类实现一个接口，但不能实现它的所有抽象方法，那么这个类只能是抽象类；
public abstract class NewCar implements Serviceable{
}
类在继承的同事可以做实现接口；
类实现接口，必须重写接口中所有抽象方法，否则该类是抽象类；
3）接口可以继承接口，多继承——尽量定义小接口（接口隔离原则）；
4、应用多态：
接口的引用 指向 实现类的对象
public class NewMerchanic {
public void service(Serviceable ser){
ser.changeOil();
ser.turnupEnginee();
if(ser instanceof Hock){
Hock h = (Hock)ser;
h.jiao();
}
if(ser instanceof Fireable){
Fireable f = (Fireable)ser;
f.fire();
}
}
}
public interface Serviceable extends Changeable,Turnupable{
}
public interface Turnupable {
public void turnupEnginee();
}
public interface Changeable {
public void changeOil();
}
public interface Fireable {
public void fire();
}
public class NewPlane implements Serviceable {
@Override
public void changeOil() {
// TODO Auto-generated method stub
System.out.println("我用的是航空机油");
}
@Override
public void turnupEnginee() {
// TODO Auto-generated method stub
System.out.println("有一个班的人为我调试引擎");
}
}
public class Hock extends NewPlane implements Fireable{
@Override
public void fire() {
// TODO Auto-generated method stub
System.out.println("可以发射捣蛋");
}
public void jiao(){
System.out.println("喔喔喔喔喔喔");
}
}
public class TestMain {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Hock h = new Hock();//可以看到Hock本类引用指向的本类对象身上所有的属性，行为
NewPlane np = new Hock();//只能看到NewPlane父类引用指向子类对象身上的属性、行为
Serviceable ser = new Hock();//只能看到Serviceable接口提供的行为
Fireable f = new Hock();//只能看到Fireable接口提供的行为
NewMerchanic fox = new NewMerchanic();
fox.service(h);
}
}
如果没有实现接口，就算有同样的方法，也不能用接口的引用区指向它的对象
5、接口与抽象类的区别：
相同特征：都不能被实例化，都位于继承的顶端，用于被其它类实现或者继承；
都包含抽象方法，实现接口或者继承抽象类的子类都必须实现这些抽象方法；
不同特征：接口中只能包含抽象类方法；抽象类中可以包含普通类方法；
接口中不能定义静态方法；抽象类可以定义静态方法；
接口只能定义静态常量属性、不能定义普通属性；抽象类既可以定义普通属性、也可以定义鼎泰常量属性；
接口不包含构造器；抽象类中可以包含构造器（抽象类中的构造器不是用于创建对象，而是让子类调用这些构造器来完成属于抽象类的初始化工作）；
接口不包含初始化块；抽象类可以包含初始化块；
语法：
| 抽象类 | 接口 |
| abstract class定义 | instanceof implements定义 |
| 抽象方法必须写abstract | 抽象方法可以不写abstract |
| 可以有变量属性，构造方法 | 不能有变量属性，只能是公共静态常量，不能有构造 |
| 可以实现了的方法 |
JDK1.7之前不能有实现的方法； JDK1.7之后可以有实现的方法，但必须有default关键字 |
使用语法：
| 用子类继承抽象类；extends（单继承） | 用实现类 实现接口，instanceof；用子接口继承接口：extends（多继承） |
设计原则：一部分类，一部分写接口；
例
小结：
接口是一个要被类实现的抽象方法集合，类用关键字implements实现接口；
实现接口的类必须实现接口中定义的每个方法，否则类必须被声明为“abstract”；
一个接口可以被用于暴露类的某些方法，也可以强制类包含某些方法；
一个类可以包含成员变量，接口中默认访问修饰符： public, static, final；
一个接口可以继承一个或多个接口；
练习题：
public interface Flyable{ public void fly(); }
public class Bird implements Flyable{ @Override public void fly(){ System.out.println("鸟拍着翅膀飞.....“）; } }
public class SuperMan implements Flyable{ @Override public void fly(){ System.out.println("超人穿着内裤飞...."); } }
public class JetPlane implements Flyable{ @Override public void fly() { System.out.println("飞机喷着气飞...."); } }
public class AirManager { public void manage ( Flyable flting ) { System.out.println("发现："); flying.fly(); if ( flying instanceof Bird){ System.out.println("马上召集人手打下来！"); }eles if(flying instanceof JetPlane){ System.out.println("发射导弹，打下来"); }else if(flying instanceof SuperMan){ System.out.println("老婆，出来看上帝！"); } } }