Java接口与多态

[b]接口[/b]

可以理解为一种特殊的类，里面全部是由全局常量（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.选择：

如果抽象类和接口都可以使用的话，优先使用接口，可以避免单继承的局限。

[b]多态[/b]

是指不同类型的对象可以响应相同的消息，从相同的基类派生出来的多个类型可被当作同一种类型对待，可对这些不同的类型进行同样的处理，由于多态性，这些不同派生类对象响应同一方法时的行为是有所差别的 ◦

例如

所有的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