java多态理解

关于多态的理解:
所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定,而是在程序运行期间才确定,即一个引用变量倒底会指向哪个类的实例对象,该引用变量发出的方法调用到底是哪个类中实现的方法,必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类,这样,不用修改源程序代码,就可以让引用变量绑定到各种不同的类实现上,从而导致该引用调用的具体方法随之改变,即不修改程序代码就可以改变程序运行时所绑定的具体代码,让程序可以选择多个运行状态,这就是多态性。

澄清
学习多态时在网上查了很多资料,发现多态有一些不同的版本,有些版本把继承,重载称为编译时多态;把继承,重写称为运行时多态。但我并不认同这种方法,我认为重载并不是多态,继承和重写才是多态。

多态==晚绑定。

不要把函数重载理解为多态。

因为多态是一种运行期的行为,不是编译期的行为。

多态:父类型的引用可以指向子类型的对象。

比如 Parent p = new Child();

当使用多态方式调用方法时,首先检查父类中是否有该方法,如果没有,则编译错误;

如果有,再去调用子类的该同名方法。

换句话说父类中有的方法子类中一定有,但子类中有的方法父类中不一定有,子类可以有自己独有的方法。

多态示例代码

public class PolyTest
{
    public static void main(String[] args)
    {
        
        //向上类型转换
        Cat cat = new Cat();
        Animal animal = cat;
        animal.sing();

                
        //向下类型转换
        Animal a = new Cat();
        Cat c = (Cat)a;
        c.sing();
        c.eat();


        //编译错误
        //用父类引用调用父类不存在的方法
        //Animal a1 = new Cat();
        //a1.eat();
        
        //编译错误
        //向下类型转换时只能转向指向的对象类型        
        //Animal a2 = new Cat();
        //Cat c2 = (Dog)a2;
        


    }
}
class Animal
{
    public void sing()
    {
        System.out.println("Animal is singing!");
    }
}
class Dog extends Animal
{
    public void sing()
    {
        System.out.println("Dog is singing!");
    }
}
class Cat extends Animal
{
    public void sing()
    {
        System.out.println("Cat is singing!");
    }
    public void eat()
    {
        System.out.println("Cat is eating!");
    }
}

Animal a1 = new Cat(); 表示父类引用可以指向子类对象
a1.sing()可以运行
a1.eat() 报错因为并没有在Animal中检测到eat()方法,eat()方法是Cat子类特有的。

如果想要使用子类中特有的方法,就需要向下类型转换

Animal a1 = new Cat();

Cat c = (Cat) a1;

c.sing(); c.eat(); 都可以运行。

但向下类型转换只能转成子类对象的类型,例如
Animal a2 = new Cat();
Cat c2 = (Dog)a2;
就是错的,编译器会报错。

然后我们在看一个复杂一点的例子:

public class A {
    public String show(D obj) {
        return ("A and D");
    }

    public String show(A obj) {
        return ("A and A");
    } 

}

public class B extends A{
    public String show(B obj){
        return ("B and B");
    }
    
    public String show(A obj){
        return ("B and A");
    } 
}

public class C extends B{

}

public class D extends B{

}

public class Test {
    public static void main(String[] args) {
        A a1 = new A();
        A a2 = new B();
        B b = new B();
        C c = new C();
        D d = new D();
        
        System.out.println("1--" + a1.show(b));
        System.out.println("2--" + a1.show(c));
        System.out.println("3--" + a1.show(d));
        System.out.println("4--" + a2.show(b));
        System.out.println("5--" + a2.show(c));
        System.out.println("6--" + a2.show(d));
        System.out.println("7--" + b.show(b));
        System.out.println("8--" + b.show(c));
        System.out.println("9--" + b.show(d));      
    }
}

输出结果:

1--A and A
2--A and A
3--A and D
4--B and A
5--B and A
6--A and D
7--B and B
8--B and B
9--A and D

大家看1,2,3可能还没有问题,但为什么第四的输出是B and A 而不是B and B呢?我们从多态在编译和运行时的行为看一下原因。

在编译阶段,针对多态的方法调用(父类引用指向子类对象)编译器会先检查父类有没有定义该方法,判断方法根据如下顺序判断优先级为:this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O),只要存在其中任意一个就算父类中有定义,编译就可以正常进行。编译完成后进入运行阶段,运行时根据编译阶段找到的父类中的方法,如果该方法对象子类中重写了则使用子类对象中的,如果没重写则使用父类中的,依次往上寻找,总可以找到。

当超类对象引用变量引用子类对象时,被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法,但是这个被调用的方法必须是在超类中定义过的,也就是说被子类覆盖的方法,但是它仍然要根据继承链中方法调用的优先级来确认方法,该优先级为:this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值