Java中的多态

目录

Java中的多态

多态是什么？

 多态的定义

多态的内存表示

多态的用法

总结

---

Java中的多态

多态是什么？

 多态的定义

多态是指父类的引用（数据类型）指向子类的对象。这种特性允许同一个方法在不同的对象中具有不同的实现。在Java中，多态的实现是通过继承和方法重写来实现的。

示例

// 父类

public class A {

}



// 子类

public class B extends A {

}



// 测试类

public class Test {

    public static void main(String[] args) {

        A ad = new B();

    }

}

在上述示例中，A ad = new B();展示了多态的概念。ad是父类A的引用，但它实际指向的是子类B的对象。这种情况下，ad只能访问A中声明的方法和属性，但是如果B类重写了A类中的方法，调用时会执行子类B中的重写方法。

多态的内存表示

为了更好地理解多态，我们需要了解对象在内存中的存储形式。

基本数据类型的内存表示比如int、byte、float等，它们在内存中的存储形式是固定的。

父类

A对象的内存结构：A类的对象在内存中有一个固定的结构，包含它的属性和方法。

子类

B对象的内存结构：B类继承自A类，因此B对象的内存结构不仅包含A的属性和方法，还包含B类自己的属性和方法。

方法重写的内存表示

当子类B重写父类A的方法时，子类对象中的方法会覆盖父类对象中的同名方法。这使得通过父类引用调用方法时，会执行子类的重写方法。

多态对象的内存表示

A ad = new B();在内存中会创建父类A的部分（因为ad是A类型），但实际存储的是子类B的对象。这种结构允许子类的方法（如果重写）在通过父类引用时也能被调用。

多态的用法

向上转型

向上转型是指子类的对象可以被父类的类型所引用。即父类的引用指向子类的对象。这种方式下，引用只能调用父类中声明的方法，无法调用子类特有的方法。

练习1：理解多态的行为

我们通过一个示例来理解向上转型和多态的行为。假设有以下类：

A类

public class A {

    public String show(D obj) {

        return ("A and D");

    }



    public String show(A obj) {

        return ("A and A");

    }

}

B类

public class B extends A {

    public String show(B obj) {

        return ("B and B");

    }



    @Override

    public String show(A obj) {

        return ("B and A");

    }

}

C类

public class C extends B {

}

D类

public class D extends B {

}

Test类

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)); // A and A

        System.out.println("2--" + a1.show(c)); // A and A

        System.out.println("3--" + a1.show(d)); // A and D



        System.out.println("4--" + a2.show(b)); // B and A

        System.out.println("5--" + a2.show(c)); // B and A

        System.out.println("6--" + a2.show(d)); // A and D



        System.out.println("7--" + b.show(b)); // B and A

        System.out.println("8--" + b.show(c)); // B and A

        System.out.println("9--" + b.show(d)); // A and D

    }

}

2详细解释

输出1:

 a1.show(b) 由于a1是A类型，只能调用A类中的方法。show(A obj)被调用，输出A and A。

输出2:

 a1.show(c) 同样的原因，a1只能调用A类的方法，输出A and A。

输出3:

 a1.show(d) 调用A类中show(D obj)，输出A and D。

输出4:

 a2.show(b) 由于a2是A类型，但是实际指向的是B对象，调用的是B类重写的show(A obj)方法，输出B and A。

输出5:

 a2.show(c) 同理，a2调用的是B类重写的show(A obj)方法，输出B and A。

输出6:

 a2.show(d) 由于D是B的子类，但A类中没有show(B obj)的重写版本，所以调用show(D obj)，输出A and D。

输出7:

 b.show(b) b是B类型对象，调用B类中的show(A obj)方法，输出B and A。

输出8:

 b.show(c) c是B的子类，向上转型为B类型，调用B类的show(A obj)，输出B and A。

输出9:

 b.show(d) d是B的子类，但B没有show(D obj)的版本，调用A类的show(D obj)方法，输出A and D。

总结

Java中的多态通过继承和方法重写实现，允许同一个方法在不同的对象中具有不同的行为。这种特性使得代码更加灵活和易于扩展。向上转型是多态的一种典型用法，通过使用父类的引用来指向子类的对象，我们可以在不修改代码的情况下实现不同的功能，这种能力使得面向对象编程更加强大和易于维护。