接口
可以理解为一种特殊的类，里面全部是由全局常量（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{……} i
nterface A extends base{……} //错误
interface A extends B, C{ ……} //正确
接口与继承的区别
No.
区别
抽象类
接口
1.定义：
以abstract声明，抽象方法可有可无。
以interface声明，由静态常量和抽象方法组成。
2.组成：
构造方法、抽象方法、普通方法、常量、变量。
静态常量、抽象方法。
3.使用：
子类继承抽象类（extends）。
子类实现接口(implements)。
4.关系：
抽象类可以实现多个接口。
接口不能继承抽象类，但允许继承多个接口。
5.对象：
都通过对象的多态性产生实例化对象。
6.局限：
抽象类有单继承的局限。
接口可以实现多重继承。
7.选择：
如果抽象类和接口都可以使用的话，优先使用接口，可以避免单继承的局限。
多态
是指不同类型的对象可以响应相同的消息，从相同的基类派生出来的多个类型可被当作同一种类型对待，可对这些不同的类型进行同样的处理，由于多态性，这些不同派生类对象响应同一方法时的行为是有所差别的 ◦
例如
所有的Object类的对象都响应toString()方法
多态性在java中主要有以下两种体现：
方法的重载与覆写。
对象的多态性。
对象的多态性
对象的多态性主要分为以下两种类型：
1.向上转型：子类对象->父类对象
对于向上转型，程序会自动完成。
//BaseClass为父类，DerivedClass为BaseClass的派生类
BaseClass bc = new DerivedClass(); //隐式转型。
2.向下转型：父类对象->子类对象
对于向下转型，必须明确指明要转型的子类类型。
BaseClass bc = 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(); //error. A中没定义fun3方法
System.out.println(a.name); //输出什么？
}
}
向下转型
public class Demo{
public static void main(String args[]){
//B b = (B)new A( ); //强制转型，运行后抛出异常
A a = new B();
B b = (B)a; //向下转型
b.fun1(); //输出什么？ A->fun1
b.fun2(); //输出什么？ A->fun2
b.fun3(); //输出什么？ B->fun3
}
}
要想产生对象的向下转型，则必须先产生一个向上的转型关系， A a = new B(); 表示建立关系。
多态的目的
所有的对象都可被转型为相同的类型，响应相同的消息 使代码变得简单且容易理解 使程序具有很好的“扩展性”
应用实例
技术基础 ◦向上转型：一个父类的引用变量可以指向不同的子类对象。 ◦动态绑定：运行时根据父类引用变量所指对象的实际类型执行相应的子类方法，从而实现多态性。 例子1：司机开车 public abstract class Driver{
public Driver( ) { }
public abstract void drives( );
}
public class FemaleDriver extends Driver {
public FemaleDriver( ) { }
public void drives( ) {
System.out.println("A Female driver drives a vehicle.");
}
}
public class MaleDriver extends Driver {
public MaleDriver( ) { }
public void drives( ) {
System.out.println("A Male driver drives a vehicle.");
}
}
public class Test{
public static void main(String [ ] args){
Driver a = new FemaleDriver( );
Driver b = new MaleDriver( );
a.drives( );
b.drives( );
}
}
输出结果：A Female driver drives a vehicle.
A Male driver drives a vehicle.
例子2——司机开什么车 不利用对象多态性的做法
public class MaleDriver extends Driver {
public MaleDriver( ) { }
public void drivesBus( ) {
System.out.println("A Male driver drives a bus.");
}
public void drivesCar( ){
System.out.println("A Male driver drives a car.");
}
public void drivesTruck( ){
System.out.println("A Male driver drives a truck.");
}
……
}
利用对象多态性的做法
public abstract class Vehicle{
public void drivedByFemale( );
public void drivedByMale();
}
public class Bus extends Vehicle{
public void drivedByFemale( ){
System.out.println("A Female driver drives a bus.");
}
public void drivedByMale(){
System.out.println("A Male driver drives a bus.");
}
}
public class MaleDriver extends Driver {
public void drives(Vehicle v){
v. drivedByMale();
}
}
public class Test{
public static void main(){
Vehicle bus = new Bus();
Driver male = new MaleDriver();
male.drives(bus);
}
}
输出结果： A Male driver drives a bus