接口
可以理解为一种特殊的类，里面全部是由全局常量（static final）和公共的抽象方法所组成
接口的定义格式
接口的数据成员，只允许被public, static, final修饰。
接口的方法成员，只允许被public, abstract修饰。
Interface 接口名称{
private static final int var1=1; //error
public static final int var2 = 2;
public abstract void fun1();
private abstract int fun2(); //error.
}
接口中的数据成员都为static final类型，必须进行初始化，且接口的数据成员的值不能被修改，允许省略static, final关键字。
接口中的方法必须是“抽象方法”，不能有方法体，允许省略public及abstract关键字
public interface A{
int num; //error. 没初始化
String name = “test”;
public void getName( ) {……} //error.不允许定义方法体
}
接口的实现
接口不能用new运算符直接产生对象，必须利用其特性设计新的类，再用新类来创建对象
与抽象类一样，接口要使用也必须通过子类，子类通过implements关键字实现接口。
实现格式：
class 子类名称 implements 接口A, 接口B，….{
//子类成员声明
}
接口的使用必须通过子类，子类必须覆写全部抽象方法。一个子类虽然只能继承于一个父类，但可以同时实现多个接口。
interface A{
public String name = “小明”;
public void print();
public String getName();
}
interface B{
public void setName();
}
class C implements A, B{
public void print( ) { ……};
public String getName( ) {……};
public void setName( ) {……};
}
必须实现接口中的所有方法，否则，实现接口的类将带有抽象方法，因此成为抽象类。
在覆写来自接口的方法时，必须声明成public。
class C implements A, B{
//public void print( ) { ……}; //没覆写print方法，编译不过。
public String getName( ) {……};
public void setName( ) {……};
}
对象转型
对象可以被转型为其所属类实现的接口类型。
接口不可通过new实例化，但可以声明接口变量。
public class Test implements A{
intidx = 1;
public void print(){
System.out.println(“”)
}
public String getName(){
}
public static void main(String []agrs){
Test test = new Test();
A a = (A)test; //对象转型为接口类型
System.out.println(a.name); //输出name的值
a.idx = 2; //error. idx属于test，在接口A中不存在
a.print(); //执行Test的print方法。
}
}
继承抽象类实现接口
一个子类可以同时继承抽象类和实现接口
格式如下：
class 子类 extends 抽象类 implements 接口A,接口B,……{ }
接口的继承
接口不能继承一个抽象类，却可以通过extends同时继承于多个接口。
public abstract class base {……}
interface B {……}
interface C{……}
interface A extends base{……} //错误
interface A extends B, C{ ……} //正确
接口与继承的区别
No.
区别
抽象类
接口
1
定义
以abstract声明，抽象方法可有可无。
以interface声明，由静态常量和抽象方法组成。
2
组成
构造方法、抽象方法、普通方法、常量、变量
静态常量、抽象方法
3
使用
子类继承抽象类（extends）
子类实现接口(implements)
4
关系
抽象类可以实现多个接口
接口不能继承抽象类，但允许继承多个接口
5
对象
都通过对象的多态性产生实例化对象
6
局限
抽象类有单继承的局限
接口可以实现多重继承
7
选择
如果抽象类和接口都可以使用的话，优先使用接口，可以避免单继承的局限
多态
是指不同类型的对象可以响应相同的消息，从相同的基类派生出来的多个类型可被当作同一种类型对待，可对这些不同的类型进行同样的处理，由于多态性，这些不同派生类对象响应同一方法时的行为是有所差别的
例如
–所有的Object类的对象都响应toString()方法
多态性在java中主要有以下两种体现：
方法的重载与覆写
对象的多态性
对象的多态性
对象的多态性主要分为以下两种类型：
向上转型：子类对象->父类对象
对于向上转型，程序会自动完成。
//BaseClass为父类，DerivedClass为BaseClass的派生类
BaseClassbc = new DerivedClass(); //隐式转型。
向下转型：父类对象->子类对象
对于向下转型，必须明确指明要转型的子类类型
BaseClassbc = new DerivedClass(); //先向上转型
DerivedClass dc = (DerivedClass)bc;
public class A{
String name = “A”;
public void fun1(){
System.out.println(“A->fun1”);
}
public void fun2(){
System.out.println(“A->fun2”);
}
}
public class B extends A{
String name = “B”;
public void fun1(){
System.out.println(“B->fun1”);
}
public void fun3(){
System.out.println(“B->fun3”);
}
}
向上转型：
public class Demo{
public static void main(String args[]){
A a = new B( );
a.fun1(); //输出什么？ B->fun1
a.fun2(); //输出什么？ A->fun2
a.fun3(); //