接口

package Polymorphism;
/*
 * 接口当中可以定义
 * 1.属性：接口中的属性，默认的修饰符是public static final
 * 2.方法：接口中的方法，默认的修饰符是public abstract 
 */
public interface MyFirstInterface {
	//接口可以定义：
	//1.方法
	public  abstract void myInterfaceMwthod();
	//接口中的方法默认的修饰符是public abstract;
	void myInterfaceMethid();
	//2.属性
	//接口中的属性默认修饰符是public static final
	int INTERFACE_PEOPERTY=10;//接口中的属性是常量

}

接口和抽象类的异同
相同点

1. 都可以编译成字节码文件
2. 都不能创建对象
3. 都可以声明引用。
4. 都具备Object类中定义的方法
5. 都可以写抽象方法

不同点

1. 接口中所有的属性，都是公开静态常量，缺省使用public static final修饰
2. 接口中所有的方法，都是公开抽象方法，缺省使用public abstrct 修饰
3. 接口中没有构造方法、构造代码段、静态代码段

接口的实现
接口需要让类实现，表示这个类具有了接口定义的能力。因为接口中有很多的抽象方法，因此，类在实现接口的时候，如果不是抽象类。必须要重写实现接口中所有的抽象方法。

package Polymorphism;

public interface MyInterface {
public static final int Interface_Field=5;//接口中的属性定义
public abstract void method();//接口中的方法定义
}
//非抽象类实现接口，必须要重写接口当中所有的抽象方法
class MyInterfaceImp implements MyInterface{
	@Override
	public void method() {
		
	}
}
//抽象类实现接口，不用重写接口中的所有的抽象方法
abstract class implements MyInterface{
	
}

类在实现接口的同时，也可以去进行继承

public interface MyInterface {
//接口中定义三个方法
void method1();
void method2();
void method3();
}
class Superclass {
	void methord1() {};
}
//Subclass继承Superclass并实现接口
class Subclass extends Superclass implements MyInterface{
@Override   //重写方法1
public void method1() {};
@Override	//重写方法2
public void method2() {};
@Override   //重写方法3
public 	void method3() {};
	
}

多个接口的实现

package Polymorphism;
/*
 * 一个类对多个接口的实现
 */
public interface MyInterface1 {
	void method1();

}

interface Myinterface2{
	void method1();
	void method2();
}
class MyInterfaceimplements implements Myinterface2,MyInterface1{   //类实现多个接口时，接口之间用,隔开
	@Override
	public void method1(){
	System.out.println("MyInterfaceimplements实现了接口1，重写了方法1");//实现多个接口时，必须实现每一个接口中间的抽象方法
	}
	//一个类实现的多个接口当中有相同的方法，实现的类只需要实现一次即可。
	@Override
	public void method2() {
		System.out.println("MyInterfaceimplements实现了接口2，重写了方法2");//实现多个接口时，必须实现每一个接口中间的抽象方法
	}
}

接口的继承
接口之间也是存在继承关系的，与类的继承相似，子接口可以继承到父接口中的所有的成员的
与类的继承不同，接口之间的继承是多继承的，也就算说，一个接口是可以有多个父接口的。子接口可以继承到所有的父接口中的成员。

package Polymorphism;

public interface Cooker {
void cook();//做饭		
void buy();//买菜
void clean();//刷碗
}
interface HouseKeeping{
	void wash();//洗衣服
	void saodi();//扫地
	
}
interface GirlFriend extends Cooker,HouseKeeping{   //接口Girlfriend继承自Cooker和HouseKeeping;
}
class Person implements GirlFriend{   //Person类实现Girlfriend接口，需要把所有的抽象方法进行实现

	@Override
	public void cook() {
		// TODO Auto-generated method stub
		System.out.println("我会煮饭");
	}

	@Override
	public void buy() {
		// TODO Auto-generated method stub
		System.out.println("我会买菜");
	}

	@Override
	public void clean() {
		// TODO Auto-generated method stub
		System.out.println("我会洗衣服");
		
	}

	@Override
	public void wash() {
		// TODO Auto-generated method stub
		System.out.println("我会刷碗");
	}

	@Override
	public void saodi() {
		// TODO Auto-generated method stub
		System.out.println("我会扫地");
	}
	public static void main(String[] args) {
		Person person=new Person();
		person.buy();
		person.clean();
		person.cook();
		person.saodi();
	}

}

接口的多态（参考类的多态）
接口的引用，可以指向实现类的对象。与类的多态相似，同样存在向上转型和向下转型。

1. 向上转型：实现类类型转型为接口类型
   是一个隐式转换，不需要任何的修饰
   向上转型后的接口引用，只能访问接口中的成员

2. 向下转型
   是一个显示转换，需要强制类型转换。
   向下转型后的实现类引用，将可以访问实现类中的成 员。