多态:Polymorphism简单的理解就是:多种形态的意思,即某一事物的多种存在形态。
比如:函数的重载,即为多态性。
看下面的例子:
class Fruit
{}
class Apple extends Fruit
{}
class Pear extends Fruit
{}
以上Apple和Pear都继承于Fruit
然后:
Apple apple = new Apple();
Fruit apple = new Apple(); //一个对象,两种形态。
在这里apple不仅具备Apple的属性,还具备Fruit的属性,
因此创建两个对象都是正确的,只不过第一个是使用本类创建的本类对象,另一个使用父类创建的子类对象。
这就是Java中对象的多态性。
简单说:就是一个对象对应着不同类型。
多态在代码中的体现:父类或者接口的引用指向其子类的对象。
多态的好处:
提高了代码的扩展性,前期定义的代码可以使用后期的内容。
看下面的例子:
anstract class Animal //抽象类
{
abstractvoid eat(); //抽象方法
}
class Dog entends Animal
{
voideat()
{
System.out.println("啃骨头");
}
voidHouseKeeping()
{
System.out.println("看家");
}
}
class Cat extends Animal
{
voideat()
{
System.out.println("吃鱼");
}
voidCatchMouse()
{
System.out.println("捉老鼠");
}
}
class PolymorphismDemo
{
publicstatic void main(String[] args)
{
Dogd = new Dog();
d.eat();
Catc = new Cat();
c.eat();
}
}
以往,我们可能会这样规划我们的程序:让对象各自去调用自己的方法,实现所需的功能。
也可以这样:
public static void main(String[]args)
{
Dogd = new Dog();
d.method();
Catc = new Cat();
c.method();
}
public static void method(Dog d)
{
d.eat();
}
public static void method(Cat c)
{
c.eat();
}
像这样,定义新的方法,更直观的调用重载函数也可以实现程序所需。
但是以上的方法都过于繁杂,代码的复用性很差,不利于扩展。
因此,可以利用多态的性质,这样做:
public static void main(String[]args)
{
method(newDog());
method(newCat());
}
public static void method(Annimala) //Animal a = new Dog();
{
a.eat();
}
上边的代码中:method()方法中参数是Animal类型,主函数调用该方法时,传入的却是Dog/Cat类型的参数。
这就是利用多态的性质实现的代码的可扩展。
加入以后需要加入新的类型,例如:
class Cock extends Animal
{
publicvoid eat()
{
System.out.println("芝麻");
}
voidcrow()
{
System.out.println("打鸣");
}
}
这里新添加了一个类,但是需要实例化并调用该类方法时,并不需要重写其方法:
可以:
method(newCock());
即完成新类型事物的功能实现。
多态的弊端:
前期定义的内容不能使用(调用)后期子类的特有内容。
多态虽然有利于程序的扩展性,但是也有局限,比如:
public static void method(Animal a)
{
a.catchMouse();
}
在主函数中调用该方法时就会出错,因为在Animal类中没有catchMouse方法的定义。
因此,使用多态时应注意多态的前提:
1,必须要有关系:继承,实现。
2,要有覆盖(子类中的特有功能覆盖父类方法)。
由于多态的局限性,在使用多态时,前期定义的内容不能使用后期子类的特有内容,因此需要对相应的对象进行形式转换。
即,转型。
简单的类型转换有:
byte b = 3;
int i = b; //将b强制转换成int类型。
因此,在这里:
Animal a = new Cat(); //实际上是类型的自动提升,Cat对象提升成了Animal类型,但是该对象不能访问Cat类型的特有功能。
//其作用就是限制对特有功能的访问。
如果想访问Cat类型的特有功能,需要将该对象进行向下转型:
Cat c = (Cat)a; //向下转型是为了使用子类中的特有功能。
c.eat();
c.catchMouse(); //此时调用该方法不会出现错误。
但是需要注意,类型转换只是同一个子类对象在做变化。
如果:
Animal a = new Animal();
Cat c = (Cat)a; //ClassCastException
此时会提示类型转换错误。
虽然这样,但是在转换的时候还是容易出现问题:
public static void method(Animal a)
{
a.eat();
//a.catchMouse(); //我们已经知道这样是行不通的
//可以做一个类型转换
Catc = (Cat)a;//向下转型,将Animal类型的a对象转换成Cat类型
c.catchMouse();//调用子类方法
}
使用的时候:
method(new Cat());
这样是没有问题的,但是如果传入的是:
method(new Dog());
这时就出现类型转换的错误提示了。
想要解决上边的问题也不太难,可以使用类型判断(instanceof:用于判断对象的具体类型,只能用于引用数据类型)来完成:
public static void method(Animal a)
{
a.eat(); //每种动物都有该方法,所以这个可以直接调用
if(ainstanceof Cat) //判断对象a是否为Cat类型
//instanceof通常用于在向下转型前健壮性的判断
{
Catc = (Cat)a;
c.catchMouse();
}
elseif(a instanceof Dog)
{
Dogd = (Dog)a;
d.houseKeeping();
}
}
这样,有了以上的判断,method()方法不管传入的是何种参数,均可以。
多态时,成员的特点:
1,成员变量(非静态)
编译时:参考引用型变量所属的类中的是否有调用的成员变量,有,编译通过,没有编译失败。
运行时:参考引用型变量所属的类中的是否有调用的成员变量,并运行该所属类中的成员变量。
简单说,编译和运行都参考等号的左边(=)。
例如:
class Fu
{
intnum = 4;
}
class Zi extends Fu
{
intnum = 5;
}
主函数中:
Fuf = new Zi();
System.out.println(f.num); //结果是4
如果在Fu类中没有定义num变量,则编译失败,因为f对象是Fu类型引用。
如果在Zi类中没有定义num变量,编译通过,输出num=4。
2,成员函数
编译时:参考引用型变量所属的类中的是否有调用的函数,有,编译通过,没有编译失败。
运行时:参考对象所属的类中是否有调用的函数。
简单说,编译看左边(=),运行看右边(=)。
例如:
class Fu
{
voidshow()
{
System.out.println("fushow");
}
}
class Zi extends Fu
{
voidshow()
{
System.out.println("zishow");
}
}
主函数中:
Fuf = new Zi();
f.show(); //zi show
如果父类中没有定义show()方法,则编译失败。因为f是Fu类的引用,当f找不到父类中的show()方法时,编译不能通过。
如果子类中没有定义show()方法,编译通过,因为编译时f首先在子类中搜索show()方法,如果没有则转向父类。
3,静态函数
编译时:参考引用型变量所属的类中的是否有调用的静态函数。
运行时:参考引用型变量所属的类中的是否有调用的静态函数。
简单说,编译和运行都看左边(=)。
其实对于静态方法,是不需要对象的,直接使用类名调用即可。
例如:
class Fu
{
staticvoid method()
{
System.out.println("fustatic method");
}
}
class Zi extends Fu
{
staticvoid method()
{
System.out.println("zistatic method");
}
}
主函数中:
Fuf = new Zi();
f.method(); //fu static method
如果:
Ziz = new Zi();
z.method(); //zi static method
等同于:
Fu.method();
Zi.method();