java-多态
多态：同一个对象拥有多种形态
举个例子，首先创建两个类：猫和狗，猫具有的动作：猫吃鱼，狗具有的动作：狗吃骨头。
代码如下：
public class cat {
public void eat(){
System.out.println("猫吃鱼");
}
}
public class dog {
public void eat(){
System.out.println("狗吃骨头");
}
}
然后，铲屎官来啦，创建一个类：人，动作是：喂猫和喂狗。
public class person {
public void feedcat(cat c){//喂猫
c.eat();//猫可以吃
}
public void feeddog(dog d){//喂狗
d.eat();//狗也有吃的动作
}
}
创建一个程序入口：client:
public class client {
public static void main(String[] args){
person p =new person();
cat c= new cat();
dog d = new dog();
p.feedcat(c);
p.feeddog(d);
}
}
然后，现在想再加一个类，大象 动作是：大象吃香蕉
public class daxiang {
public void eat(){
System.out.println(“大象吃香蕉”);
}
}
然后人，需要再加一个动作就是，喂大象：
public class person {
public void feedcat(cat c){
c.eat();
}
public void feeddog(dog d){
d.eat();
}
public void feeddaxiang(daxiang dx){
dx.eat();
}
}
person类中需要再加一个动作就是喂大象：
public class person {
public void feedcat(cat c){
c.eat();
}
public void feeddog(dog d){
d.eat();
}
public void feeddaxiang(daxiang dx){
dx.eat();
}
}
client也需要加入：
public class client {
public static void main(String[] args){
person p =new person();
cat c= new cat();
dog d = new dog();
daxiang dx=new daxiang();
p.feedcat(c);
p.feeddog(d);
p.feeddaxiang(dx);
}
}
但是可以看到，其实person代码中是有很多重复的，怎么可以简写呢？
可以想到，猫是一种动物，狗也是一种动物，大象也是一种动物。（）什么是一种什么，也就想到了Java中的继承。
创建一个动物的类：
public class animal {
public void eat(){
System.out.println("动物在吃");
}
}
输出：
然后那些猫、狗、大象就都可以继承动物的属性，吃
我们知道 cat c = new cat();就是创建一只猫，也就是创建了猫类型的猫，那么可以把猫当成动物来看，也就是：animal ani = new cat();
然后所有的类都可以继承动物的属性了，因此：
public class daxiang extends animal
public class dog extends animal
public class cat extends animal
然后程序入口即：
public class client {
public static void main(String[] args){
// person p =new person();
// cat c= new cat();
// dog d = new dog();
// daxiang dx=new daxiang();
// p.feedcat(c);
// p.feeddog(d);
// p.feeddaxiang(dx);
animal ani1 = new cat();//可以把猫当成动物来看，把子类的对象赋值给父类的引用(变量)，向上转型
animal ani2=new dog();
animal ani3=new daxiang();
person p = new person();
p.feedanimal(ani1);
p.feedanimal(ani2);
p.feedanimal(ani3);
}
}
类：人就可以改了：
public class person {
public void feedanimal(animal ani){//接收到的所有的动物都是animal
ani.eat();//这里就有多态性的体现啦
}
// public void feedcat(cat c){
// c.eat();
// }
// public void feeddog(dog d){
// d.eat();
// }
// public void feeddaxiang(daxiang dx){
// dx.eat();
//
// }
}
输出：
那么，有向上转型，就有向下转型
比如，猫还有抓老鼠的本领，但是动物并没有。因此向上转型的缺点就出来了，它会屏蔽子类中特有的属性。因此，使用向下转型转回来：
cat新加一个方法，抓老鼠
public class cat extends animal {
public void eat(){
System.out.println("猫吃鱼");
}
public void catchmouse(){
System.out.println("猫抓老鼠");
}
}
修改程序入口：
public class client {
public static void main(String[] args){
// person p =new person();
// cat c= new cat();
// dog d = new dog();
// daxiang dx=new daxiang();
// p.feedcat(c);
// p.feeddog(d);
// p.feeddaxiang(dx);
animal ani1 = new cat();//可以把猫当成动物来看，把子类的对象赋值给父类的引用(变量)，向上转型
animal ani2=new dog();
animal ani3=new daxiang();
person p = new person();
p.feedanimal(ani1);
p.feedanimal(ani2);
p.feedanimal(ani3);
cat cc = (cat)ani1;//向下转型，
cc.catchmouse();
}
}
输出:
举例一个习题，一个三个玩家打三个游戏：
首先创建一个Game 类：
public class Game {
public void start(){
System.out.println("开机啦");
}
public void play(){
System.out.println("玩游戏");
}
public void end(){
System.out.println("关机啦");
}
}
然后三个游戏的类，图中可知，和Game 是继承关系：
贪吃蛇
public class tanchishe extends Game{
public void play(){
System.out.println("喜欢玩贪吃蛇");
}
}
消消乐：
public class xiaoxiaole extends Game{
public void play(){
System.out.println("消消乐太好玩了");
}
}
原神：
public class yuanshen extends Game{
public void play(){
System.out.println("玩原神的都聪明");
}
}
然后创建玩家player类：
public class player {
public void happy(Game game){
game.start();
game.play();
game.end();
System.out.println("开心的很呢！");
}
}
然后创建程序入口：
要求是创建三个游戏对象，然后新建一个玩家对象，然后这个玩家去玩这三个游戏。
public class client {
public static void main(String[] args){
Game game1= new tanchishe();
Game game2= new xiaoxiaole();
Game game3= new yuanshen();
player play = new player();
play.happy(game1);
play.happy(game2);
play.happy(game3);
}
}