Java多态

多态

同一个对象在不同时刻表现出来的不同状态

举 :猫
猫是猫: 猫 cat = new 猫();
猫是动物: 动物 cat = new 猫();
猫在不同时刻体现出来了不同状态，这个就是多态

多态的前提和体现
1.有继承/实现关系
2.有方法重写
3.有父类引用指向子类对象

For example

定义三个类
Animal
Cat
AnimalDemo	// 测试类

package com.study_01;
public class Animal {
    public void eat() {
        System.out.println("动物吃东西");
    }
}
-----
package com.study_01;
// 多态前提第一步  继承关系
public class cat extends Animal{
    // 第二步  eat()方法重写
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
-----
package com.study_01;
public class AnimalDemo {
    public static void main(String[] args) {
        // 第三步 有父类引用指向子类对象
        Animal a = new cat();
        a.eat(); // 猫吃鱼
    }
}

---

多态的成员访问的特点

成员变量：编译看左边，执行看左边
成员方法：编译看左边，执行看右边

Question:为什么成员变量和成员方法的访问不一样呢?
因为成员方法有重写，而成员变量没有

For example

定义三个类
Animal
Cat
AnimalDemo	// 测试类

package com.study_02;

public class Animal {
	// 父类的成员变量
    public int age = 40;

    public void eat() {
        System.out.println("动物吃东西");
    }
}
-----
package com.study_02;
// 有继承
public class Cat extends Animal{

    public int age = 20;
    public int weight = 10;
	// 有方法重写
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    public void playGame() {
        System.out.println("猫捉迷藏");
    }
}
-----
package com.study_02;

public class AnimalDemo {

    public static void main(String[] args) {
        // 有父类引用指向子类对象
        Animal a  = new Cat();

        System.out.println(a.age); // 40
        // 成员变量  编译看左边,运行看左边
        // 最终呈现的其实是动物类里面age变量的值
//        System.out.println(a.weight); // 编译看左边,动物类里面并没有weight变量,所以报错

        a.eat(); // 猫吃鱼
        // 成员方法  编译看左边,运行看右边
//        a.playGame;
		// 编译看左边,动物里面没有playGame()方法,该方法时Cat类特有的
    }
}

多态的好处和弊端

好处：提高了程序的扩展性

具体体现：定义方法的时候，使用父类类型作为参数，将来在使用的时候，使用具体的子类型参与操作

弊端：不能使用子类的特有功能

For example

定义五个类
Animal
Cat
Dog
AnimalOperateor  // 操作类
AnimalDemo	// 测试类

package com.study_03;
public class Animal {
    public void eat() {
        System.out.println("动物吃东西");
    }
}
-----
package com.study_03;
// 继承父类
public class Cat extends Animal {
	// 重写父类方法
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
-----
package com.study_03;
public class Dog extends Animal{
	// 重写父类方法
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    public void lookDoor() {
        System.out.println("狗看门");
    }
}
------
package com.study_03;
/*
    动物操作类
*/
public class AnimalOperator {
   /* 
   // 这样写较为复杂
   public void useAnimal(Cat c) { // Cat c = new Cat();
        c.eat();
    }
    
    public void useAnimal(Dog d) {
        d.eat();
    }*/
	
	// 这样写毕竟好
    public void useAnimal(Animal a) {
        // Animal a = new Cat();
        // Animal a = new Dog();

        a.eat();
        // 不能使用子类的特有功能
//         a.lookDoor();
    }
}
-----
package com.study_03;
public class AnimalDemo {
    public static void main(String[] args) {
        // 创建动物操作类的对象,调用方法
        AnimalOperator ao =new AnimalOperator();
        Cat c = new Cat();
        ao.useAnimal(c);

        Dog d = new Dog();
        ao.useAnimal(d);
    }
}

多态中的转型

向上转型

• 从子到父
• 父类引用指向子类对象

向下转型

• 从父到子
• 父类引用转为子类对象

For example

定义三个类
Animal
Cat
AnimalDemo	// 测试类

package com.study_04;
public class Animal {
    public void eat() {
        System.out.println("动物吃东西");
    }
}
-----
package com.study_04;
public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    public void playGame() {
        System.out.println("猫捉迷藏");
    }
}
-----
package com.study_04;
public class AnimalDemo {
    public static void main(String[] args) {
        // 多态
        Animal a  = new Cat(); // 向上转型
        a.eat();
//        a.playGame(); // 编译看左边,Animal中没有playGame()这个方法

        /*Cat c = new Cat();
        c.eat();
        c.playGame();*/

        // 向下转型,这样就可以调用Cat类里面特有的方法了
        Cat c = (Cat) a;
        c.eat();
        c.playGame();
    }
}