java多态难点讲解.docx
《java多态难点讲解.docx》由会员分享，可在线阅读，更多相关《java多态难点讲解.docx（23页珍藏版）》请在冰点文库上搜索。
java多态难点讲解
1多态概念
/*
多态：
同一个对象（事物），在不同时刻体现出来的不同状态。
举例：
猫是猫，猫是动物。
水（液体，固体，气态）。
多态的前提：
A:
要有继承关系。
B:
要有方法重写。
其实没有也是可以的，但是如果没有这个就没有意义。
动物d=new猫（）;
d.show（）;
动物d=new狗（）;
d.show（）;
C:
要有父类引用指向子类对象。
父f=new子（）;
用代码体现一下多态。
多态中的成员访问特点：
A:
成员变量
编译看左边，运行看左边。
B:
构造方法
创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化。
C:
成员方法
编译看左边，运行看右边。
D:
静态方法
编译看左边，运行看左边。
（静态和类相关，算不上重写，所以，访问还是左边的）
由于成员方法存在方法重写，所以它运行看右边。
*/
classFu{
publicintnum=100;
publicvoidshow（）{
System.out.println（"showFu"）;
}
publicstaticvoidfunction（）{
System.out.println（"functionFu"）;
}
}
classZiextendsFu{
publicintnum=1000;
publicintnum2=200;
publicvoidshow（）{
System.out.println（"showZi"）;
}
publicvoidmethod（）{
System.out.println（"methodzi"）;
}
publicstaticvoidfunction（）{
System.out.println（"functionZi"）;
}
}
classDuoTaiDemo{
publicstaticvoidmain（String[]args）{
//要有父类引用指向子类对象。
//父f=new子（）;
Fuf=newZi（）;
System.out.println（f.num）;
//找不到符号
//System.out.println（f.num2）;
f.show（）;
//找不到符号
//f.method（）;
f.function（）;
}
}
2多态好处
/*
多态的好处：
A:
提高了代码的维护性（继承保证）
B:
提高了代码的扩展性（由多态保证）
猫狗案例代码
*/
classAnimal{
publicvoideat（）{
System.out.println（"eat"）;
}
publicvoidsleep（）{
System.out.println（"sleep"）;
}
}
classDogextendsAnimal{
publicvoideat（）{
System.out.println（"狗吃肉"）;
}
publicvoidsleep（）{
System.out.println（"狗站着睡觉"）;
}
}
classCatextendsAnimal{
publicvoideat（）{
System.out.println（"猫吃鱼"）;
}
publicvoidsleep（）{
System.out.println（"猫趴着睡觉"）;
}
}
classPigextendsAnimal{
publicvoideat（）{
System.out.println（"猪吃白菜"）;
}
publicvoidsleep（）{
System.out.println（"猪侧着睡"）;
}
}
//针对动物操作的工具类
classAnimalTool{
privateAnimalTool（）{}
/*
//调用猫的功能
publicstaticvoiduseCat（Catc）{
c.eat（）;
c.sleep（）;
}
//调用狗的功能
publicstaticvoiduseDog（Dogd）{
d.eat（）;
d.sleep（）;
}
//调用猪的功能
publicstaticvoidusePig（Pigp）{
p.eat（）;
p.sleep（）;
}
*/
publicstaticvoiduseAnimal（Animala）{
a.eat（）;
a.sleep（）;
}
}
classDuoTaiDemo2{
publicstaticvoidmain（String[]args）{
//我喜欢猫，就养了一只
Catc=newCat（）;
c.eat（）;
c.sleep（）;
//我很喜欢猫，所以，又养了一只
Catc2=newCat（）;
c2.eat（）;
c2.sleep（）;
//我特别喜欢猫，又养了一只
Catc3=newCat（）;
c3.eat（）;
c3.sleep（）;
//...
System.out.println（"--------------"）;
//问题来了,我养了很多只猫，每次创建对象是可以接受的
//但是呢?
调用方法，你不觉得很相似吗?
仅仅是对象名不一样。
//我们准备用方法改进
//调用方式改进版本
//useCat（c）;
//useCat（c2）;
//useCat（c3）;
//AnimalTool.useCat（c）;
//AnimalTool.useCat（c2）;
//AnimalTool.useCat（c3）;
AnimalTool.useAnimal（c）;
AnimalTool.useAnimal（c2）;
AnimalTool.useAnimal（c3）;
System.out.println（"--------------"）;
//我喜欢狗
Dogd=newDog（）;
Dogd2=newDog（）;
Dogd3=newDog（）;
//AnimalTool.useDog（d）;
//AnimalTool.useDog（d2）;
//AnimalTool.useDog（d3）;
AnimalTool.useAnimal（d）;
AnimalTool.useAnimal（d2）;
AnimalTool.useAnimal（d3）;
System.out.println（"--------------"）;
//我喜欢宠物猪
//定义一个猪类，它要继承自动物，提供两个方法，并且还得在工具类中添加该类方法调用
Pigp=newPig（）;
Pigp2=newPig（）;
Pigp3=newPig（）;
//AnimalTool.usePig（p）;
//AnimalTool.usePig（p2）;
//AnimalTool.usePig（p3）;
AnimalTool.useAnimal（p）;
AnimalTool.useAnimal（p2）;
AnimalTool.useAnimal（p3）;
System.out.println（"--------------"）;
//我喜欢宠物狼，老虎，豹子...
//定义对应的类，继承自动物，提供对应的方法重写，并在工具类添加方法调用
//前面几个必须写，我是没有意见的
//但是，工具类每次都改，麻烦不
//我就想，你能不能不改了
//太简单：
把所有的动物都写上。
问题是名字是什么呢?
到底哪些需要被加入呢?
//改用另一种解决方案。
}
/*
//调用猫的功能
publicstaticvoiduseCat（Catc）{
c.eat（）;
c.sleep（）;
}
//调用狗的功能
publicstaticvoiduseDog（Dogd）{
d.eat（）;
d.sleep（）;
}
*/
}
3多态坏处
/*
多态的弊端：
不能使用子类的特有功能。
*/
classFu{
publicvoidshow（）{
System.out.println（"showfu"）;
}
}
classZiextendsFu{
publicvoidshow（）{
System.out.println（"showzi"）;
}
publicvoidmethod（）{
System.out.println（"methodzi"）;
}
}
classDuoTaiDemo3{
publicstaticvoidmain（String[]args）{
//测试
Fuf=newZi（）;
f.show（）;
f.method（）;
}
}
/*
多态的弊端：
不能使用子类的特有功能。
我就想使用子类的特有功能?
行不行?
行。
怎么用呢?
A:
创建子类对象调用方法即可。
（可以，但是很多时候不合理。
而且，太占内存了）
B:
把父类的引用强制转换为子类的引用。
（向下转型）
对象间的转型问题：
向上转型：
Fuf=newZi（）;
向下转型：
Ziz=（Zi）f;//要求该f必须是能够转换为Zi的。
*/
classFu{
publicvoidshow（）{
System.out.println（"showfu"）;
}
}
classZiextendsFu{
publicvoidshow（）{
System.out.println（"showzi"）;
}
publicvoidmethod（）{
System.out.println（"methodzi"）;
}
}
classDuoTaiDemo4{
publicstaticvoidmain（String[]args）{
//测试
Fuf=newZi（）;
f.show（）;
//f.method（）;
//创建子类对象
//Ziz=newZi（）;
//z.show（）;
//z.method（）;
//你能够把子的对象赋值给父亲，那么我能不能把父的引用赋值给子的引用呢?
//如果可以，但是如下
Ziz=（Zi）f;
z.show（）;
z.method（）;
}
}
5类型转换异常
/*
ClassCastException:
类型转换异常
一般在多态的向下转型中容易出现
*/
classAnimal{
publicvoideat（）{}
}
classDogextendsAnimal{
publicvoideat（）{}
publicvoidlookDoor（）{
}
}
classCatextendsAnimal{
publicvoideat（）{
}
publicvoidplayGame（）{
}
}
classDuoTaiDemo5{
publicstaticvoidmain（String[]args）{
//内存中的是狗
Animala=newDog（）;
Dogd=（Dog）a;
//内存中是猫
a=newCat（）;
Catc=（Cat）a;
//内存中是猫
Dogdd=（Dog）a;//ClassCastException
}
}
6多态猫狗案例
/*
多态练习：
猫狗案例
*/
classAnimal{
publicvoideat（）{
System.out.println（"吃饭"）;
}
}
classDogextendsAnimal{
publicvoideat（）{
System.out.println（"狗吃肉"）;
}
publicvoidlookDoor（）{
System.out.println（"狗看门"）;
}
}
classCatextendsAnimal{
publicvoideat（）{
System.out.println（"猫吃鱼"）;
}
publicvoidplayGame（）{
System.out.println（"猫捉迷藏"）;
}
}
classDuoTaiTest{
publicstaticvoidmain（String[]args）{
//定义为狗
Animala=newDog（）;
a.eat（）;
System.out.println（"--------------"）;
//还原成狗
Dogd=（Dog）a;
d.eat（）;
d.lookDoor（）;
System.out.println（"--------------"）;
//变成猫
a=newCat（）;
a.eat（）;
System.out.println（"--------------"）;
//还原成猫
Catc=（Cat）a;
c.eat（）;
c.playGame（）;
System.out.println（"--------------"）;
//演示错误的内容
//Dogdd=newAnimal（）;
//Dogddd=newCat（）;
//ClassCastException
//Dogdd=（Dog）a;
}
}
7多态饮食案例
/*
不同地方饮食文化不同的案例
*/
classPerson{
publicvoideat（）{
System.out.println（"吃饭"）;
}
}
classSouthPersonextendsPerson{
publicvoideat（）{
System.out.println（"炒菜,吃米饭"）;
}
publicvoidjingShang（）{
System.out.println（"经商"）;
}
}
classNorthPersonextendsPerson{
publicvoideat（）{
System.out.println（"炖菜,吃馒头"）;
}
publicvoidyanJiu（）{
System.out.println（"研究"）;
}
}
classDuoTaiTest2{
publicstaticvoidmain（String[]args）{
//测试
//南方人
Personp=newSouthPerson（）;
p.eat（）;
System.out.println（"-------------"）;
SouthPersonsp=（SouthPerson）p;
sp.eat（）;
sp.jingShang（）;
System.out.println（"-------------"）;
//北方人
p=newNorthPerson（）;
p.eat（）;
System.out.println（"-------------"）;
NorthPersonnp=（NorthPerson）p;
np.eat（）;
np.yanJiu（）;
}
}
8多态测试
/*
看程序写结果:
先判断有没有问题，如果没有，写出结果
*/
classFu{
publicvoidshow（）{
System.out.println（"fushow"）;
}
}
classZiextendsFu{
publicvoidshow（）{
System.out.println（"zishow"）;
}
publicvoidmethod（）{
System.out.println（"zimethod"）;
}
}
classDuoTaiTest3{
publicstaticvoidmain（String[]args）{
Fuf=newZi（）;
//找不到符号
//f.method（）;
f.show（）;
}
}
9多态成员访问特点
/*
看程序写结果:
先判断有没有问题，如果没有，写出结果
多态的成员访问特点：
方法：
编译看左边，运行看右边。
继承的时候：
子类中有和父类中一样的方法，叫重写。
子类中没有父亲中出现过的方法，方法就被继承过来了。
*/
classA{
publicvoidshow（）{
show2（）;
}
publicvoidshow2（）{
System.out.println（"我"）;
}
}
classBextendsA{
/*
publicvoidshow（）{
show2（）;
}
*/
publicvoidshow2（）{
System.out.println（"爱"）;
}
}
classCextendsB{
publicvoidshow（）{
super.show（）;
}
publicvoidshow2（）{
System.out.println（"你"）;
}
}
publicclassDuoTaiTest4{
publicstaticvoidmain（String[]args）{
Aa=newB（）;
a.show（）;
Bb=newC（）;
b.show（）;
}
}
10多态继承与转型
多态的问题理解：
class孔子爹{
publicintage=40;
publicvoidteach（）{
System.out.println（"讲解JavaSE"）;
}
}
class孔子extends孔子爹{
publicintage=20;
publicvoidteach（）{
System.out.println（"讲解论语"）;
}
publicvoidplayGame（）{
System.out.println（"英雄联盟"）;
}
}
//Java培训特别火,很多人来请孔子爹去讲课，这一天孔子爹被请走了
//但是还有人来请，就剩孔子在家，价格还挺高。
孔子一想，我是不是可以考虑去呢?
//然后就穿上爹的衣服，带上爹的眼睛，粘上爹的胡子。
就开始装爹
//向上转型
孔子爹k爹=new孔子（）;
//到人家那里去了
System.out.println（k爹.age）;//40
k爹.teach（）;//讲解论语
//k爹.playGame（）;//这是儿子才能做的
//讲完了，下班回家了
//脱下爹的装备，换上自己的装备
//向下转型
孔子k=（孔子）k爹;
System.out.println（k.age）;//20
k.teach（）;//讲解论语
k.playGame（）;//英雄联盟
11多态继承中内存的问题
2多态中对象变化内存图解
升级会员 