简体中文(ZH-CN) English(EN) 繁体中文(ZH-TW) 日本語(JA) 한국어(KO) Melayu(MS) Français(FR) Deutsch(DE)
首页 > Java > java教程 > 正文

03.Java 基础 - 多态

黄舟
发布： 2017-02-27 10:13:11
原创
1377 人浏览过

基本概念

多态是同一个行为具有多个不同表现形式或形态的能力。

多态性是对象多种表现形式的体现。

多态发生的条件 ：继承、重写、向上转型

动态绑定是多态实现的具体形式。

实例探究

下面通过一个例子验证上面的概念。

// 车class Car {    public void show(){
        System.out.println("This is a car");
    }
}//丰田class Toyota extends Car{    public void show(){
        System.out.println("This is a Japan car");
    }
}//别克class Buick extends Car{    public void show(){
        System.out.println("This is a USA car");
    }
}public class Test{  
    public static void main(String[] args) {
        Car c1 = new Toyota();
        Car c2 = new Buick();
        c1.show();
        c2.show();        // 打印内容：
        // This is a Japan car
        // This is a USA car
    }
}
登录后复制
登录后复制
登录后复制

观察代码，在调用 Car 的 show 方法时打印了不同的内容，体现了类的多态性。同时例子也满足了发生多态的三个基本条件：

  • 继承：Toyota 、Buick 继承自 Car

  • 重写： Toyota 、Buick 重写了 Car 的 show 方法

  • 向上转型：创建 Toyota 、Buick 对象时发生向上转型

再来看来一个典型题目：

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

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

class C extends B {
}

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();        // 1.因此 B 是 A 的子类，调用类 A 的 show(A obj) 方法，输出：A and A
        System.out.println(a1.show(b));        // 2.因为 C 是 A 的子类，调用类 A 的 show(A obj) 方法，输出：A and A
        System.out.println(a1.show(c));        // 3.调用类 A 的 show(D obj) 方法，输出：A and D
        System.out.println(a1.show(d));        // 4.因为 B 向上转型成 A， 且 B 是 A 的子类，调用类 A 的 show(A obj) 方法
        // 但是由于 B 中重写了 show(A obj) 方法，导致运行期间发生的动态绑定，调用 类 B 的 show(A obj) 方法
        // ，输出：B and A
        System.out.println(a2.show(b));        // 5.同上
        System.out.println(a2.show(c));        // 6.B 向上转型成 A，默认调用类 A 的 show(D obj) 方法，输出：A and D
        System.out.println(a2.show(d));        // 7.调用类 B 的 show(B obj) 方法，输出：B and B
        System.out.println(b.show(b));        // 8.C 是 B 的子类，调用类 B 的 show(B obj) 方法，输出：B and B
        System.out.println(b.show(c));        // 9.调用继承自类 A 的 show(D obj) 方法，输出：A and D
        System.out.println(b.show(d));

    }
}
登录后复制
登录后复制

构造器与多态

同样的通过一个实例来探究

class Parent {    void print() {
        System.out.println("I am a Parent");
    }

    Parent() {
        print();
    }
}

class Son extends Parent {    int num = 1;    // 重写（override）了父类方法
    void print() {
        System.out.println("I am a Son " + num);
    }

    Son() {
        print();
    }
}public class Test {
    public static void main(String[] args) {
        Son son = new Son();        /**
         * 输出内容： 
         * I am a Son 0
         * I am a Son 1
         */
    }
}
登录后复制
登录后复制

通过输出内容我们可以看到，Parent 的构造器由于动态绑定，调用了 Son 的 print（），由于 num 还未被初始化，导致了值为 0。

基本概念

多态是同一个行为具有多个不同表现形式或形态的能力。

多态性是对象多种表现形式的体现。

多态发生的条件 ：继承、重写、向上转型

动态绑定是多态实现的具体形式。

实例探究

下面通过一个例子验证上面的概念。

// 车class Car {    public void show(){
        System.out.println("This is a car");
    }
}//丰田class Toyota extends Car{    public void show(){
        System.out.println("This is a Japan car");
    }
}//别克class Buick extends Car{    public void show(){
        System.out.println("This is a USA car");
    }
}public class Test{  
    public static void main(String[] args) {
        Car c1 = new Toyota();
        Car c2 = new Buick();
        c1.show();
        c2.show();        // 打印内容：
        // This is a Japan car
        // This is a USA car
    }
}
登录后复制
登录后复制
登录后复制

观察代码，在调用 Car 的 show 方法时打印了不同的内容，体现了类的多态性。同时例子也满足了发生多态的三个基本条件：

  • 继承：Toyota 、Buick 继承自 Car

  • 重写： Toyota 、Buick 重写了 Car 的 show 方法

  • 向上转型：创建 Toyota 、Buick 对象时发生向上转型

再来看来一个典型题目：

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

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

class C extends B {
}

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();        // 1.因此 B 是 A 的子类，调用类 A 的 show(A obj) 方法，输出：A and A
        System.out.println(a1.show(b));        // 2.因为 C 是 A 的子类，调用类 A 的 show(A obj) 方法，输出：A and A
        System.out.println(a1.show(c));        // 3.调用类 A 的 show(D obj) 方法，输出：A and D
        System.out.println(a1.show(d));        // 4.因为 B 向上转型成 A，应该是调用类 A 的 show(A obj) 方法
        // 由于 B 中重写了 show(A obj) 方法，实际调用 类 B 的方法，，输出：B and A
        System.out.println(a2.show(b));        // 5.同上
        System.out.println(a2.show(c));        // 6.B 向上转型成 A，默认调用类 A 的 show(D obj) 方法，输出：A and D
        System.out.println(a2.show(d));        // 7.调用类 B 的 show(B obj) 方法，输出：B and B
        System.out.println(b.show(b));        // 8.C 是 B 的子类，调用类 B 的 show(B obj) 方法，输出：B and B
        System.out.println(b.show(c));        // 9.调用继承自类 A 的 show(D obj) 方法，输出：A and D
        System.out.println(b.show(d));

    }
}
登录后复制

构造器与多态

同样的通过一个实例来探究

class Parent {    void print() {
        System.out.println("I am a Parent");
    }

    Parent() {
        print();
    }
}

class Son extends Parent {    int num = 1;    // 关键 -> 重写了父类的方法
    void print() {
        System.out.println("I am a Son " + num);
    }

    Son() {
        print();
    }
}public class Test {
    public static void main(String[] args) {
        Son son = new Son();        // 输出内容： 
        // I am a Son 0
        // I am a Son 1
    }
}
登录后复制

分析结果，其实它涉及到了三个内容：

  • Son 在实例化的过程中，Parent 的构造函数， Parent 的构造函数先执行。

  • Son 重写了 print 方法，因此 Parent 调用的是 Son 重写后的方法。

  • 在 Parent 由于 num 还未被初始化，因此值为 0。

基本概念

多态是同一个行为具有多个不同表现形式或形态的能力。

多态性是对象多种表现形式的体现。

多态发生的条件 ：继承、重写、向上转型

动态绑定是多态实现的具体形式。

实例探究

下面通过一个例子验证上面的概念。

// 车class Car {    public void show(){
        System.out.println("This is a car");
    }
}//丰田class Toyota extends Car{    public void show(){
        System.out.println("This is a Japan car");
    }
}//别克class Buick extends Car{    public void show(){
        System.out.println("This is a USA car");
    }
}public class Test{  
    public static void main(String[] args) {
        Car c1 = new Toyota();
        Car c2 = new Buick();
        c1.show();
        c2.show();        // 打印内容：
        // This is a Japan car
        // This is a USA car
    }
}
登录后复制
登录后复制
登录后复制

观察代码，在调用 Car 的 show 方法时打印了不同的内容，体现了类的多态性。同时例子也满足了发生多态的三个基本条件：

  • 继承：Toyota 、Buick 继承自 Car

  • 重写： Toyota 、Buick 重写了 Car 的 show 方法

  • 向上转型：创建 Toyota 、Buick 对象时发生向上转型

再来看来一个典型题目：

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

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

class C extends B {
}

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();        // 1.因此 B 是 A 的子类，调用类 A 的 show(A obj) 方法，输出：A and A
        System.out.println(a1.show(b));        // 2.因为 C 是 A 的子类，调用类 A 的 show(A obj) 方法，输出：A and A
        System.out.println(a1.show(c));        // 3.调用类 A 的 show(D obj) 方法，输出：A and D
        System.out.println(a1.show(d));        // 4.因为 B 向上转型成 A， 且 B 是 A 的子类，调用类 A 的 show(A obj) 方法
        // 但是由于 B 中重写了 show(A obj) 方法，导致运行期间发生的动态绑定，调用 类 B 的 show(A obj) 方法
        // ，输出：B and A
        System.out.println(a2.show(b));        // 5.同上
        System.out.println(a2.show(c));        // 6.B 向上转型成 A，默认调用类 A 的 show(D obj) 方法，输出：A and D
        System.out.println(a2.show(d));        // 7.调用类 B 的 show(B obj) 方法，输出：B and B
        System.out.println(b.show(b));        // 8.C 是 B 的子类，调用类 B 的 show(B obj) 方法，输出：B and B
        System.out.println(b.show(c));        // 9.调用继承自类 A 的 show(D obj) 方法，输出：A and D
        System.out.println(b.show(d));

    }
}
登录后复制
登录后复制

构造器与多态

同样的通过一个实例来探究

class Parent {    void print() {
        System.out.println("I am a Parent");
    }

    Parent() {
        print();
    }
}

class Son extends Parent {    int num = 1;    // 重写（override）了父类方法
    void print() {
        System.out.println("I am a Son " + num);
    }

    Son() {
        print();
    }
}public class Test {
    public static void main(String[] args) {
        Son son = new Son();        /**
         * 输出内容： 
         * I am a Son 0
         * I am a Son 1
         */
    }
}
登录后复制
登录后复制

通过输出内容我们可以看到，Parent 的构造器由于动态绑定，调用了 Son 的 print（），由于 num 还未被初始化，导致了值为 0。

分析结果，其实它涉及到了三个内容：

  • Son  在实例化的过程中，Parent  的构造函数， Parent  的构造函数先执行。

  • Son 重写了 print 方法，因此 Parent 调用的是 Son 重写后的方法。

  • 在 Parent 由于 num 还未被初始化，因此值为 0。

 以上就是03.Java 基础 - 多态的内容，更多相关内容请关注PHP中文网（www.php.cn）！


相关标签：
Java，多态
来源：php.cn
上一篇：02.Java 基础 - 继承 下一篇：04.Java 基础 - 类
本站声明
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系admin@php.cn
作者最新文章
最新问题
无法将数据从 useState 发布到 Mysql 我试图将输入数据从useState发布到Mysql，但它没有发生。虽然我能够将数据从数据库获取到页面，但是当涉及到发布时，当有很多值时，我不知道如何将数据从状态挂钩发送到mysql...
来自于 2024-04-03 10:53:49
0
1
280
创建一个类似于toast ui主页的导航栏 我的灵感来源我想制作这样的导航栏：Toastui主页我做了什么我尝试尽可能多地复制来实现这一目标。我得到以下信息：我想要什么我想要像这样的（这些是通过图像编辑制作的）：选项1：居中...
来自于 2024-04-01 18:34:38
0
1
240
flex css - 在一定高度后剪辑元素而不是换行 边框代表静态高度和宽度。我希望第5项和第6项保留在第二行，并剪掉第3项和第6项，而不是如图所示第三次包裹。我如何通过Flex实现这一目标？为了补充这个问题，容器的宽度（用边框显示）...
来自于 2024-04-01 14:02:02
0
1
396
从表中消除 a 列中具有重复值的行 有没有办法检查lead_id是否在表中多次出现，如果是，则从查询中排除？原因是我只想在status_id=1并且没有找到该Lead_id的其他status_id/行时添加新行。数据...
来自于 2024-03-31 10:42:26
0
1
268
当使用 useEffect 传递给子 React 组件时，函数被多次调用 我有一个包含多个ChildComponent标签的页面，我希望每个ChildComponent都被告知要根据用户单击的ChildComponent来调用哪个API。onClick(...
来自于 2024-03-30 15:36:26
0
2
386
相关专题
更多>
热门推荐
热门教程
更多>
相关教程
热门推荐
最新课程
最新下载
更多>
网站特效
网站源码
网站素材
前端模板
关于我们 免责声明 Sitemap
PHP中文网：公益在线PHP培训，帮助PHP学习者快速成长！