Java学习笔记 --- 面向对象之多态

最新推荐文章于 2023-03-24 10:04:14 发布
最新推荐文章于 2023-03-24 10:04:14 发布
阅读量469 收藏 1
点赞数 1
分类专栏： Java基础 文章标签： 学习 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a1404359447/article/details/127226313
版权

一、基本介绍

方法或对象具有多种形态，是面向对象的三大特征，多态是建立在封装和继承之上的

二、多态的具体体现

1、方法的多态：

重写和重载就体现多态

案例演示：

package com.javase.poly_;

public class PloyMethod {
    public static void main(String[] args) {
        //方法重载体现多态
        A a = new A();
        //我们传入不同的参数，调用不同的方法
        System.out.println(a.sum(10, 20));
        System.out.println(a.sum(10, 20, 30));

        //方法重写体现多态
        B b = new B();
        a.say();
        b.say();
        //虽然是同一方法，但根据对象不一样调用结果是不一样的。
    }
}

class B {//父类
    public void say() {
        System.out.println("B say 方法被调用...");
    }
}

class A extends B {//子类
    public int sum(int n1, int n2) {
        return n1 + n2;
    }
    public int sum(int n1, int n2, int n3) {
        return n1 + n2 + n3;
    }
    public void say() {
        System.out.println("A say 方法被调用...");
    }
}

2、对象的多态

1.一个对象的编译类型和运行类型可以不一致。

2.编译类型在定义对象时，就确定了，不能改变

3.运行类型是可以变化的。

4.编译类型看定义时 = 号的左边，运行类型看 = 号的右边。

案例演示：

Animal类

package com.javase.poly_.objectpoly_;

public class Animal {
    public void cry() {
        System.out.println("动物叫...");
    }
}

Dog类：

package com.javase.poly_.objectpoly_;

public class Dog extends Animal{
    public void cry() {
        System.out.println("小狗汪汪叫...");
    }
}

Cat类：

package com.javase.poly_.objectpoly_;

import com.javase.super_.A;

public class Cat extends Animal {
    public void cry() {
        System.out.println("小猫喵喵叫...");
    }
}

输出：

package com.javase.poly_.objectpoly_;

public class PolyObject {
    public static void main(String[] args) {
        //animal编译类型是 Animal ，运行类型是Dog
        Animal animal = new Dog();
        animal.cry();//因为animal运行类型是Dog,所以会调用Dog里面的cry方法
        animal = new Cat();
        animal.cry();//因为animal运行类型变成了Cat,所以会调用Cat里面的cry方法
    }
}

三、多态的注意事项和细节讨论

多态的前提是：两个对象(类)存在继承关系。

1、多态的向上转型

本质上，父类的引用指向了子类对象。

在语法上：父类类型  引用名 = new 子类类型();

编译类型看左边，运行类型看右边，可以调用父类中的所有成员，但必须遵守访问权限，不能调用子类中特有成员，最终运行效果看子类的具体实现。

案例演示：

package com.javase.poly_.detail_;

public class Animal {
    public void eat() {
        System.out.println("吃");
    }
    public void run() {
        System.out.println("跑");
    }
}

package com.javase.poly_.detail_;

public class Cat extends Animal {
    public void eat() {//方法重写
        System.out.println("猫吃鱼");
    }
    public void catchMouse() {//特有方法
        System.out.println("猫抓老鼠");
    }
}

输出：

package com.javase.poly_.detail_;

public class PolyDetail {
    public static void main(String[] args) {
        Animal animal = new Cat();
        Object obj = new Cat();//Object也是Cat父类

        //最终运行效果看子类的具体实现，即调用方法时，从子类开始查找方法
        animal.eat();//猫吃鱼
        animal.run();//跑
    }
}

2、 多态的向下转型

在语法上：子类类型 引用名 = （子类类型）父类引用

只能强转父类引用，不能强转父类对象

要求父类的引用必须指向的是当前目标类型的对象

当向下转型后，可以调用子类类型中所有的成员

案例演示：

package com.javase.poly_.detail_;

public class Animal {
    public void eat() {
        System.out.println("吃");
    }
    public void run() {
        System.out.println("跑");
    }
}

package com.javase.poly_.detail_;

public class Cat extends Animal {
    public void eat() {//方法重写
        System.out.println("猫吃鱼");
    }
    public void catchMouse() {//特有方法
        System.out.println("猫抓老鼠");
    }
}

输出

package com.javase.poly_.detail_;

public class PolyDetail {
    public static void main(String[] args) {
        Animal animal = new Cat();

        //多态的向下转型
        Cat cat = (Cat) animal;//编译类型是Cat 运行类型也是Cat
        cat.catchMouse();//可以调用子类里面的特有方法
    }
}

 3、属性没有重写，属性的值看编译类型

package com.javase.poly_.detail_;

public class PolyDetail01 {
    public static void main(String[] args) {
        //编译类型是Base 运行类型是 Sun
        Base b = new Sun();
        System.out.println(b.n1);//属性的值看编译类型，结果为10
        Sun sun = new Sun();
        System.out.println(sun.n1);//20
    }
}

class Base {
    int n1 = 10;
}

class Sun extends Base {
    int n1 = 20;
}

4、instanceOf比较操作符，用于判断对象的运行类型是否为某个类型或某个类型的子类型。

package com.javase.poly_.detail_;

public class PolyDetail02 {
    public static void main(String[] args) {
        BB bb = new BB();
        System.out.println(bb instanceof BB);//true
        System.out.println(bb instanceof AA);//true

        //用于判断对象的运行类型是否为某个类型或某个类型的子类型
        //编译类型AA 运行类型BB
        AA aa = new BB();
        System.out.println(aa instanceof AA);//true
        System.out.println(aa instanceof BB);//true

        Object o = new Object();
        System.out.println(o instanceof AA);//false
    }
}

class AA{}

class BB extends AA {
}

四、入门练习

1.请说出下面的每条语音，哪些是正确的，哪些是错误的，为什么？

package com.javase.poly_.exercise_;

public class PolyExercise01 {
    public static void main(String[] args) {
        double d = 13.4;//正确
        long l = (long) d;//正确
        System.out.println(l);//13.4
        int in = 5;//正确
        boolean b = (boolean) in;//错误，boolean不能转换成int类型
        Object obj = "hello";//正确 向上转型
        String objStr = (String) obj;//正确 向下转型
        System.out.println(objStr);//hello

        Object objPri = new Integer(5);//正确 向上转型
        String str = (String) objPri;//错误 指向Integer的父类引用，转成String
        Integer str1 = (Integer) objPri;//正确 向下转型
    }
}

2.输出结果是什么：

输出：

20

20

true

10

20

五、动态绑定机制

1、当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定

2、当调用对象属性时，没有动态绑定机制，哪里声明，那里使用。

package com.javase.poly_.dynamic_;

public class DynamicBinding {
    public static void main(String[] args) {
        A a = new B();
        System.out.println(a.sum());//40 -> 30
        System.out.println(a.sum1());//30 -> 20
    }
}

class A {
    public int i = 10;

    //动态绑定机制
    public int sum() {
        //调用的子类B的getl()
        return getl() + 10;
    }
    public int sum1() {
        //当调用对象属性时，没有动态绑定机制，哪里声明，那里使用。
        return i + 10;
    }
    public int getl() {
        return i;
    }
}

class B extends A {
    public int i = 20;

//    public int sum() {
//        return i + 20;
//    }
//    public int sum1() {
//        return i + 10;
//    }
    public int getl() {
        return i;
    }
}

六、多态的应用

1、多态数组

数组的定义类型为父类类型，里面保存的实际元素类型为子类型。

案例演示：

Person类

package com.javase.poly_.polyarr_;

public class Person {
    private String name;
    private int age;

    public Person(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 String say() {
        return "name=" + name + " age=" + age;
    }
}

Student 类 

package com.javase.poly_.polyarr_;

public class Student extends Person {
    private double score;

    public Student(String name, int age, double score) {
        super(name, age);
        this.score = score;
    }

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    public String say() {
        return super.say() + " 成绩=" + score;
    }
}

Teacher类 

package com.javase.poly_.polyarr_;

public class Teacher extends Person {
    private double salary;

    public Teacher(String name, int age, double salary) {
        super(name, age);
        this.salary = salary;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public String say() {
        return super.say() + " 薪水=" + salary;
    }
}

输出：

package com.javase.poly_.polyarr_;

public class PolyArray {
    public static void main(String[] args) {
        Person[] persons = new Person[5];
        persons[0] = new Person("张三", 20);
        persons[1] = new Student("李四", 15, 79.5);
        persons[2] = new Student("王五", 16, 60.0);
        persons[3] = new Teacher("铁蛋", 25, 30000);
        persons[4] = new Teacher("二丫", 30, 60000);

        for (int i = 0; i < persons.length; i++) {
            //编译类型是Person 运行类型是根据实际情况由JVM来判断
            System.out.println(persons[i].say());//多态绑定机制
        }
    }
}

如何在多态数组中调用子类特有的方法：

在Teacher类 新增特有的方法

public void teach() {
    System.out.println("老师 " + getName() + " 正在讲课...");
}

在Student类 新增特有的方法

public void study() {
    System.out.println("学生 " + getName() + "正在听课...");
}

输出：

package com.javase.poly_.polyarr_;

public class PolyArray {
    public static void main(String[] args) {
        Person[] persons = new Person[5];
        persons[0] = new Person("张三", 20);
        persons[1] = new Student("李四", 15, 79.5);
        persons[2] = new Student("王五", 16, 60.0);
        persons[3] = new Teacher("铁蛋", 25, 30000);
        persons[4] = new Teacher("二丫", 30, 60000);

        for (int i = 0; i < persons.length; i++) {
            //编译类型是Person 运行类型是根据实际情况由JVM来判断
            System.out.println(persons[i].say());//多态绑定机制

            //使用instanceof 判断 persons[i] 是不是Student类型
            if(persons[i] instanceof Student) {
//                Student student = ;//向下转型
//                student.study();//调用子类特有方法
                ((Student) persons[i]).study();
            }else if(persons[i] instanceof Teacher) {
                ((Teacher) persons[i]).teach();
            }

        }
    }
}

2、多态参数

方法定义的形参类型为父类类型，实参类型允许为子类型

案例演示：

Employee类

package com.javase.poly_.polyparameter;

public class Employee {
    private String name;
    private double sal;

    public Employee(String name, double sal) {
        this.name = name;
        this.sal = sal;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getSal() {
        return sal;
    }

    public void setSal(double sal) {
        this.sal = sal;
    }
    
    //计算年工资
    public double getAnnual() {
        return sal * 12;
    }
}

Worker类 

package com.javase.poly_.polyparameter;

public class Worker extends Employee{

    public Worker(String name, double sal) {
        super(name, sal);
    }

    //子类特有方法
    public void work() {
        System.out.println("普通员工 " + getName() + " 正在工作...");
    }
    //共有方法
    public double getAnnual() {
        return super.getAnnual();
    }
}

 Manager类

package com.javase.poly_.polyparameter;

public class Manager extends Employee{
    private double bonus;

    public Manager(String name, double sal, double bonus) {
        super(name, sal);
        this.bonus = bonus;
    }

    public double getBonus() {
        return bonus;
    }

    public void setBonus(double bonus) {
        this.bonus = bonus;
    }

    //子类特有方法
    public void manage() {
        System.out.println("经理 " + getName() + " 正在管理员工...");
    }
    //共有方法
    public double getAnnual() {
        return super.getAnnual() + bonus;
    }
}

输出：

package com.javase.poly_.polyparameter;

public class PolyParameter {
    public static void main(String[] args) {
        Worker zs = new Worker("张三", 2000);
        Manager ls = new Manager("李四", 5000, 1000);
        PolyParameter polyParameter = new PolyParameter();
        polyParameter.showEmpAnnual(zs);
        polyParameter.showEmpAnnual(ls);

        polyParameter.test(zs);
        polyParameter.test(ls);

    }
    //获取员工的年薪
    public void showEmpAnnual(Employee e) {
        System.out.println(e.getAnnual());
    }
    
    public void test(Employee e) {
        if(e instanceof Worker) {//判断对象类型
            ((Worker) e).work();//向下转型
        }else if(e instanceof Manager) {
            ((Manager) e).manage();
        }
    }
}

 

乌云不要说话
关注
专栏目录
Java学习笔记-面向对象-001-面向对象概括
06-05
同时，阅读优秀的Java学习笔记和参考书籍，参与在线社区和论坛讨论，都可以帮助你加快学习进度，提高编程技能。在Java的世界里，不断探索和实践，你将能够构建出高效、可靠的面向对象软件系统。
《java学习》-java学习笔记.zip
最新发布
04-02
这份《java学习》笔记包含了多个核心主题，旨在帮助初学者和有经验的开发者深入理解和掌握Java技术。 1. **正则表达式（正则.md）**： 正则表达式在Java中用于文本匹配和搜索，是处理字符串的强大工具。Java提供了...
Java面向对象之多态
nanyuanchixian的博客
05-21 297
本文对多态进行简述，帮助Java初学者理解多态
【JAVA】面向对象之多态
m0_68828538的博客
10-18 160
方法或对象具有多种形态，是OOP第三大特征，前两大是封装和继承。多态是建立在封装和继承基础上的。
Java-面向对象三大特性之多态
qq_52998673的博客
07-25 277
Java-面向对象三大特性之多态
Java基础——面向对象三大特征之多态
千锋教育
03-24 451
我们知道，面向对象有三大特征：封装、继承和多态。现在我们已经了解了封装和继承，接下来在本文中，给大家带来面向对象的第三大特征：多态。在这篇文章中，我们要弄清楚多态的含义、特点、作用，以及如何用代码进行实现。全文大约【6000】字，不说废话，只讲可以让你学到技术、明白原理的纯干货！本文带有丰富的案例及配图，让你更好地理解和运用文中的技术概念，并可以给你带来具有足够启迪的思考1. 概念多态(polymorphism)本来是生物学里的概念，表示地球上的生物在形态和状态方面的多样性。
java 面向对象三大特性之多态 万字详解（超详细）
Cyan_RA9的博客
02-25 2646
Java 面向对象三大特性——多态篇！
Java-多态--学习笔记.docx
07-05
Java中的多态性是面向对象编程的一个核心特性，它允许我们设计更加灵活和可扩展的代码。在Java中，多态性（Polymorphism）主要体现在两个方面：方法的重写（Overriding）和接口的实现（Interface Implementation）。...
java学习笔记-java思维导图流程图表格整理
11-19
Java是一种广泛使用的面向对象的编程语言，其设计目标是具有高度的可移植性，能够“一次编写，到处运行”。在Java的学习过程中，了解并掌握基本语法和核心概念至关重要。以下是一些关键知识点的详细说明： 1. **...
2022年Java学习笔记-Java课程配套案例.rar
12-19
这份"2022年Java学习笔记-Java课程配套案例.rar"压缩包文件显然是为了帮助学习者深入理解Java编程，通过实践案例来巩固理论知识。下面将详细探讨Java语言的一些核心知识点，并结合压缩包中的案例进行说明。 1. **...
Java面向对象三大基本特征之多态
lv121218的博客
11-24 1432
Java面向对象三大基本特征之多态
【Java面向对象】多态的详细介绍，简单易懂，看这一篇就够了
Ceylan__的博客
10-31 2378
方法或对象具有多种形态，是面向对象的第三大特征，多态是建立在封装和继承的基础之上的。简单来说，多态是具有表现多种形态的能力的特征。
重走Java基础：面向对象-多态及其常见问题
凝练于心博客
11-20 265
一、多态概述 多态是继封装、继承之后，面向对象的第三大特性。 现实事物经常会体现出多种形态，如学生，学生是人的一种，则一个具体的同学张三既是学生也是人，即出现两种形态。 Java作为面向对象的语言，同样可以描述一个事物的多种形态。如Student类继承了Person类，一个Student的对象便既是Student，又是Person。 Java中多态的代码体现在一个子类对象(实现类对象)既可以给这个...
面向对象的三个基本特征：封装、继承、多态及常见问题
余_yu的博客
03-13 500
面向对象的三个基本特征：封装、继承、多态及常见问题 文章目录面向对象的三个基本特征：封装、继承、多态及常见问题面向对象和面向过程的区别面向过程面向对象封装继承多态常见问题接口和抽象类，继承和实现重写和重载父类引用、子类引用、父类对象和子类对象父类子类中不同内容的初始化顺序 本文介绍面向对象的三个基本特征：封装、继承、多态，以及常见问题如：父类子类初始化顺序，接口和抽象类，对象和引用等。 面向对象和面向过程的区别 面向过程 面向过程是具体化的，流程化的，解决一个问题，你需要一步一步的分析，一步一步的实现。 优
JAVA面向对象 多态 异常 异常解决方案
无名氏—不学代码的博客
06-28 428
1 多态 1.1概念 多态是面向对象程序设计（OOP）的一个重要特征，指同一个实体同时具有多种形式，即同一个对象，在不同时刻，代表的对象不一样，指的是对象的多种形态。 可以把不同的子类对象都当作父类来看，进而屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，统一调用标准。 比如，你的女盆友让你买点水果回来，不管买回来的是苹果还是西瓜，只要是水果就行，这个就是生活中多态的体现 再比如，小猫、小狗、小猪我们可以把他们都归纳成小动物，但是每种小动物爱吃的东西不一样，具体的小动物有具体的食物，如下代码所示
创建一个 List，在 List 中增加三个工人，Worker 类基本信息如下：
liuzhijun_ld的博客
12-30 1004
import java.security.PublicKey; import java.util.ArrayList; import java.util.List; import java.util.Scanner; public class WorkerSysten { Scanner input = new Scanner(System.in); List<Work> li = new ArrayList<>(); public void show..
[阶段3 企业开发基础] 10. 前端基础 JS篇
欢迎光临~
10-11 324
前端基础--js
Java理解误区——方法的重载是多态性的一种体现？
Duktig的博客
06-05 5792
理解误区——方法的重载是多态性的一种体现？ 方法的重载是多态性的一种体现吗？ 其实这是一个误区，让我很长的一段时间都理解错了，直到又一次系统复习Java的时候才理解，方法的重载并不是是多态性的一种体现. 什么才是多态性？
重载不是多态的体现形式
Stan的专栏
09-02 4557
下面这段文字来字《Java In Thinking 3》Polymorphism means “different forms.”In object-oriented programming, you have the same face(the common interface in the base class) and different forms useing the face: the
Java学习笔记：面向对象、继承与多态
"Java学习笔记包含了面向对象编程的多个核心概念，如继承、方法重写、属性覆盖、super关键字的使用、final关键字的作用、抽象类的定义与使用、接口的实现以及对象的多态性。" Java学习笔记深入探讨了面向对象编程的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值