多态概述：
同一个对象，在不同时刻表现出来的不同形态
举例：猫
我们可以说猫是猫：猫 cat=new 猫();
我们也可以说猫是动物：动物 animal=new 猫();
这里猫在不同的时刻表现出来了不同的形态，这就是多态
多态的前提和体现
- 有继承/实现关系
- 有方法重写
- 有父类引用指向子类对象
多态中成员访问特点
- 成员变量：编译看左边，执行看左边
- 成员方法：编译看左边，执行看右边
为什么成员变量和成员方法的访问不一样呢？
- 因为成员方法有重写，而成员变量没有
eg：
package Java;
public class Animal {
public int age=40;
public void eat(){
System.out.println("动物吃东西");
}
}
package Java;
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 Java;
/*
测试类*/
public class AnimalDemo {
public static void main(String[] args){
//有父类引用指向子类对象
Animal a = new Cat();
System.out.println(a.age);
a.eat();
}
}
终端：
40
猫吃鱼
多态的好处和弊端
- 好处：提高了程序的扩展性
具体体现：定义方法的同时，使用父类型作为参数，将来在使用的时候，使用具体的子类型参与操作 - 弊端：不能使用子类的特有功能
eg：
package Java;
public class Animal {
public int age=40;
public void eat(){
System.out.println("动物吃东西");
}
}
package Java;
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 Java;
public class Dog extends Animal{
@Override
public void eat(){
System.out.println("狗吃骨头");
}
}
package Java;
/*
动物操作类
*/
public class AnimalOperator {
/*public void useAnimal(Cat c){
c.eat();
}
public void useAnimal(Dog d){
d.eat();
}
*/
public void useAnimal(Animal a){
//Animal a=new Cat();
//Animal a=new Dog();
a.eat();
}
}
package Java;
/*
测试类*/
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);
}
}
终端：
猫吃鱼
狗吃骨头
多态中的转型
- 向上转型
从父到子
父类引用指向子类对象 - 向下转型
从父到子
父类引用转为子类对象
eg：
package Java;
public class Animal {
public void eat(){
System.out.println("动物吃东西");
}
}
package Java;
public class Cat extends Animal{
@Override
public void eat(){
System.out.println("猫吃鱼");
}
public void playGame(){
System.out.println("猫捉迷藏");
}
}
package Java;
/*
测试类*/
public class AnimalDemo {
public static void main(String[] args){
//多态
Animal a=new Cat();//向上转型
a.eat();
//创建Cat类的对象
Cat c=new Cat();
c.eat();
c.playGame();
}
}
终端：
猫吃鱼
猫吃鱼
猫捉迷藏
eg：
package Java;
public class Animal {
public void eat(){
System.out.println("动物吃东西");
}
}
package Java;
public class Cat extends Animal{
@Override
public void eat(){
System.out.println("猫吃鱼");
}
public void playGame(){
System.out.println("猫捉迷藏");
}
}
package Java;
/*
测试类*/
public class AnimalDemo {
public static void main(String[] args){
//多态
Animal a=new Cat();//向上转型
a.eat();
//向下转型
Cat c = (Cat) a;
c.eat();
c.playGame();
}
}
终端：
猫吃鱼
猫吃鱼
猫捉迷藏
案例：猫和狗
需求：请采用多态的思想实现猫和狗的案例，并在测试类中进行测试
package Java;
public class Animal {
private String name;
private int age;
public Animal(){
}
public Animal(String name,int age){
this.name=name;
this.age=age;
}
public String getName(){
return name;
}
public void setName(String name){
this.name=name;
}
public int getAge(){
return age;
}
public void setAge(int age){
this.age=age;
}
public void eat(){
System.out.println("动物吃东西");
}
}
package Java;
public class Cat extends Animal{
public Cat(){
}
public Cat(String name,int age){
super(name, age);
}
@Override
public void eat(){
System.out.println("猫吃鱼");
}
}
package Java;
public class Dog extends Animal{
public Dog(){
}
public Dog(String name,int age){
super(name, age);
}
@Override
public void eat(){
System.out.println("狗吃骨头");
}
}
package Java;
/*
测试类
*/
public class AnimalDemo {
public static void main(String[] args){
//创建猫类对象进行测试
Animal a=new Cat();
a.setName("加菲");
a.setAge(5);
System.out.println(a.getName()+","+a.getAge());
a.eat();
a=new Cat("加菲", 5);
System.out.println(a.getName()+","+a.getAge());
a.eat();
}
}
终端：
加菲,5
猫吃鱼
加菲,5
猫吃鱼
