多态:是指同一行为具有多个不同表现形式。
前提条件:
- 继承或者实现【二选一】
- 方法的重写【意义体现:不重写,无意义】
- 父类引用指向子类对象【格式体现】父类 对象名 = new 子类对象()
多态的体现格式:
父类类型 变量名 = new 子类对象;
变量名.方法名();
代码如下:
Fu f = new Zi();
f.method();
当时用多态方式调用方法时,首先检查父类中是否有该方法,如果没有,则编译错误;如果有,执行的是子类重写后方法。
代码如下:
定义父类:
public abstract class Animal{
public abstract void eat();
}
定义子类:
class Cat extends Animal{
public void eat(){
System.out.println("吃鱼“);
}
}
class Dog extends Animal{
public void eat(){
System.out.println("吃骨头“);
}
}
定义测试类:
public class Test{
public static void main(String[] args){
//多态形式,创建对象
Animal a1 = new Cat();
//调用的是Cat的eat
a1.eat();
//多态形式,创建对象
Animal a2 = new Dog();
//调用的是Dog的eat
a2.eat();
}
}
多态的好处
在实际开发过程中,父类类型作为方法形式参数,传递子类对象的方法,进行方法的调用,更能体现出多态的扩展性与便利性。
定义父类:
public abstract class Animal{
public abstract void eat();
}
定义子类:
public Cat extends Animal{
public void eat(){
System.out.println("吃鱼“);
}
}
public Dog extends Animal{
public void eat(){
System.out.println("吃骨头“);
}
}
定义测试类:
public class Test{
public static void main(String[] args){
//多态形式,创建对象
Cat c = new Cat();
Dog d = new Dog();
//调用showCatEat
showCatEat(c);
//调用showDogEat
showDogEat(d);
//以上两个方法,均可以被showAnimalEat(Animal a)方法所替代
//而且执行效果一致
showAnimalEat(c);
showAnimalEat(d);
}
public static void showCatEat(Cat c){
c.eat();
}
public static void showDogEat(Dof d){
d.eat();
}
public static void showAnimalEat(Animal a){
a.eat();
}
}
由于多态特性的支持,showAnimalEat方法的Animal类型,是Cat和Dog的父类类型,Cat和Dog的父类类型,父类类型接收子类对象,当然可以把Cat对象和Dog对象,传递给方法。
当eat方法执行时,多态规定,执行的是子类重写的方法,那么效果自然与showCatEat、showDogEat方法一致,所以showAnimalEat完全可以替代以上两个方法。
不仅仅是替代,在扩展性方面,无论之后再多的子类出现,我们都不需要编写showXxxEat方法了,直接使用showAnimalEat都可以完成。
所以,多态的好处体现在可以使编程更简洁,并有良好的扩展。
引用类型转换
向上转型:多态本身是子类类型向上转换的过程,这个过程是默认的。
当父类引用指向一个子类对象时,便是向上转型。
使用格式:
父类类型 变量名 = new 子类类型();
如:Animal a = new Cat();
向下转型:父类类型向子类类型向下转换的过程,这个过程是强制的。
一个已经向上转型的子类对象,将父类引用装换为子类引用,可以使用强制类型转换的格式。
使用格式:
子类类型 变量名 = (子类类型) 父类变量名;
如:Cat c = (Cat) a;
为什么要转型?
abstract class Animal{
abstract void eat();
}
class Cat extends Animal{
public void eat(){
System.out.println("吃鱼");
}
public void catchMouse(){
System.out.println("抓老鼠");
}
}
class Dog extends Animal{
public void eat(){
System.out.println("吃骨头");
}
public void watchHouse(){
System.out.println("看家");
}
}
定义测试类:
public class Test{
public static void main(String[] args){
//向上转型
Animal a = new Cat();
a.eat();//调用的是Cat的eat
//向下转型
Cat c = (Cat)a;
c.catchMouse();//调用的是cat的catchMouse
转型的异常
转型过程中,一不下心就会遇到这样的问题,代码如下:
pubic class Test{
public static void main(String[] args){
//向上转型
Animal a = new Cat();
a.eat();//调用的是Cat的eat
//向下转型
Dog d = (Dod)a;
d.watchHouse();//调用的是Dog的watchHouse【运行报错】
}
}
这段代码可以通过编译,但运行时却报出了ClassCastException,类型转换异常!!这是因为,明明创建了Cat对象,运行时,当然不能转换成Dog对象。这两种没有继承关系,不符合类型转换的定义。
为了避免ClassCastException的发生,Java提供了instance关键字,给引用变量做类型校验,格式如下:
变量名 instanceof 数据类型
如果变量属于该数据类型,返回true
如果变量不属于该数据类型,返回false
所以转换前,我们最好做一个判断:
public class test{
public static void main (String[] args){
//向下转型
Animal a new Cat();
a.eat();
//调用的是Cat的eat
//向下转型
if(a instanceof Cat){
Cat c = (Cat)a;
c.catchMouse();//调用的是Cat的catchMouse
}else if(a instanceof Dog){
Dog d = (Dog)a;
//调用的是Dog的watchHouse
}
}
}
案例需求
//定义鼠标、键盘、笔记本三者之间应该遵守的规则
public interface USB{
void open();//开启功能
voidclose();//关闭功能
}
//鼠标实现USB规则
public class Mouse implements USB{
public void open(){
System.out.println("鼠标开启");
}
public void close(){
System.out.println("键盘关闭");
}
}
//键盘实现USB规则
public class keyBoard implemenets USB{
public void open(){
System.out.println("键盘开启");
}
public void close(){
System.out.println("键盘关闭");
}
}
//定义笔记本
public class NoteBook{
//笔记本开启运行功能
public void run(){
System.out.println("笔记本运行");
}
//笔记本使用USB设备,这时当笔记本对象调用这个功能时,必须给其传递一个符合USB规则的USB设备
public void useUSB(USB usb){
//判断是否有USB设备
if(usb!=null){
usb.open();
usb.close();
}
}
public void shutDown(){
System.out.println("笔记本关闭");
}
}
//测试
public class Test{
public static void main(String[] args){
//创建笔记本实体对象
NoteBook nb = new BoteBook();
//笔记本开启
nb.run();
//创建鼠标实体对象
Mouse m = new Mouse();
//笔记本使用鼠标
nb.usbUSB(m);
//创建键盘实体对象
KeyBoard kb = new KeyBoard();
//笔记版使用键盘
nb.usbUSB(kb);
//笔记本关闭
nb.shutDown();
}
}