接口

接口：

　　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("老婆，出来看上帝！");
    }
    }
}