详细讲解java中的多态

1、多态概述

同一对象在不同时刻表现不同的形态

举例：猫

猫 cat=new 猫；（猫是猫）

动物 animal=new 猫（猫是动物）

猫在不同时刻表现出不同状态就是多态

多态的前提和表现：

1、有继承和实现关系

2、有方法重写

3、有父类引用指向子类对象

代码实现多态：

父类：

package animals;

public class animal {
    public void eat(){
        System.out.println("动物");
    }
}

子类：

package animals;

public class cat extends animal {
    @Override
    public void eat() {
        super.eat();
        System.out.println("猫吃鱼");

    }
}

测试：

package animals;

public class test {
    public static void main(String[] args) {
    animal a=new cat();
    a.eat();
    }
}
//输出：
动物
猫吃鱼

多态中成员变量和方法的访问特点：

父类：

package animals;

public class animal {
    public int age=20;//成员变量

    public void eat(){//成员方法
        System.out.println("动物");
    }
}

子类：

package animals;

public class cat extends animal {
    public int age=12;
    public int weight=10;

    @Override
    public void eat() {
        super.eat();//调用父类中成员方法
        System.out.println("猫吃鱼");
    }

    public void playgame(){
        System.out.println("捉迷藏");
    }
}

测试代码；

package animals;

public class test {
    public static void main(String[] args) {
    animal a=new cat();//父类引用指向子类对象，多态创建对象
    a.eat();

    //编译看左边，animal中并没有weight，因此无法通过多态使用子类中的weight
    System.out.println(a.age);//输出结果为20，//多态访问成员变量访问的是父类的成员变量
        //多态访问成员变量，编译和运行都看左边

        a.eat();//无法使用子类中的成员方法，
        //多态访问成员方法，编译也得看左边，左边animal没有就无法访问
        //输出 动物  猫吃鱼  说明多态访问成员方法，编译看左边animal有没有，运行看右边子类的方法定义
    }
}

多态访问总结：

1、成员变量；编译看左边，运行看左边

2、成员方法：编译看左边，运行看右边

原因：成员方法有重写，成员变量没有

 多态的好处和弊端

父类：

package jicheng;

public class animal {
    public void eat(){
        System.out.println("动物吃东西");
    }
}

子类：

package jicheng;

public class cat extends animal {
    @Override
    public void eat() {
        super.eat();
        System.out.println("猫池骨头");
    }
}

第二个子类：

package jicheng;

public class dog extends animal{
    @Override
    public void eat() {
        super.eat();
        System.out.println("狗吃骨头");
    }
}

对子类进行操作的代码：

package jicheng;

public class operator {

//    public void usinganimal(cat c){//cat c=new cat();
//        c.eat();
//    }
//    public void usinganimal(dog d){
//        d.eat();
//    }

    //上述猫和狗都继承了animal我们现在定义一个普遍的方法
    //因此上述代码可以简写为：
    public void operatoranimal(animal a){

        //animal a=new cat();
        //animal a=new dog();
        a.eat();
    }
}

测试代码：

package jicheng;

public class test {
    public static void main(String[] args) {
        //创建操作类对象，调用方法
        operator o=new operator();

        cat c=new cat();//方法的参数是猫类，因此先要创建对象
        o.usinganimal(c);//c作为方法的参数，相当于在operator中创建对象：cat c=new cat();

        dog d=new dog();
        o.usinganimal(d);
    }
    
}
输出：
动物吃东西
猫池骨头
动物吃东西
狗吃骨头

总结：

多态的好处：

提高程序可扩展性：定义方法使用父类型作为参数，使用的时候用具体子类参与操作

弊端；不能具有（调用）子类特有功能

多态中的转型 

1、向上转型  从子到父  父类引用指向子类对象

2、向下转型 从父到子  父类引用转为子类对象

代码实现：

package zhuanxing;

public class animal {
    public void eat(){
        System.out.println("动物");
    }

}

子类：

package zhuanxing;

public class cat extends animal{
    @Override//重写方法
    public void eat() {
        super.eat();
        System.out.println("猫类");
    }
    //定义自己特有方法
    public void play(){
        System.out.println("玩耍");
    }
}

测试代码：

package zhuanxing;

public class test {
    public static void main(String[] args) {
        //利用多态创建对象
        animal a=new cat();//父类引用指向子类对象  也叫做向上转型
        a.eat();

        //如果想要调用猫类的特有方法可以：(创建猫类对象)
//        cat c=new cat();
//        c.eat();
//        c.play();

        //向下转型：
        cat c=(cat)a;
        c.eat();
        c.play();
    }
}