面向对象编程之多态

已于 2022-10-11 15:40:09 修改
阅读量252 收藏
点赞数
分类专栏： java 文章标签： java jvm mybatis servlet spring
于 2022-09-22 21:41:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57385165/article/details/127219321
版权

1 先看一个问题

1663684757406

使用传统的方法来解决(private 属性)

传统的方法带来的问题是什么? 如何解决?

问题是： 代码的复用性不高，而且不利于代码维护

解决方案： 引出我们要讲解的多态

package com.yt.poly;

public class Ploy01 {
    public static void main(String[] args) {
        Master master = new Master("tom");
        Dog dog = new Dog("dahuang");
        Bone bone = new Bone("bone");
        master.feed(dog,bone);

        Cat cat = new Cat("xiaomiao");
        Fish fish = new Fish("黄花鱼");
        master.feed(cat,fish);

    }
}

//7.创建主人master类
class Master {
    private String name;

    public Master(String name) {
        this.name = name;
    }

    //使用多态机制，可以统一的管理主人喂食的问题
    //animal 编译类型是Animal,可以指向(接收) Animal子类的对象
    //food 编译类型是Food ,可以指向(接收) Food子类的对象
    public void feed(Animal animal, Food food) {
        System.out.println("主人 " + name + " 给 " + animal.getName() + " 吃 " + food.getName());
    }

//    public void feed(Dog dog, Bone bone){
//        System.out.println("主人" + name + " 给" + dog.getName() + " 喂" + bone.getName());
//    }

//    public void feed(Cat cat, Fish fish){
//        System.out.println("主人" + name + " 给" + cat.getName() + " 喂" + fish.getName());
//    }

    //如果动物很多，食物很多
    //===> feed 方法很多，不利于管理和维护
    //Pig --> Rice
    //Tiger ---> meat ...
    //...


    public String getName() {
        return name;
    }

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

//6.创建Dog类，继承Animal类
class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }
}

//5.创建Cat类，继承Animal类
class Cat extends Animal {
    public Cat(String name) {
        super(name);
    }
}

//4.创建Animal类
class Animal {
    private String name;

    public Animal(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

//3.创建Bone类，继承食物Food类
class Bone extends Food {
    public Bone(String name) {
        super(name);
    }
}

//2.创建Fish类，继承食物Food类
class Fish extends Food {

    public Fish(String name) {
        super(name);
    }

//    @Override
//    public String getName() {
//        return name;
//    }
//
//    @Override
//    public void setName(String name) {
//        this.name = name;
//    }
}

//1.创建食物类
class Food {
    private String name;

    public Food(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

2 基本介绍

多[多种]态[状态]

方法或对象具有多种形态。

是面向对象的第三大特征，多态是建立在封装和继承基础之上的。

3.方法的多态

重载方法和重写方法

public class PloyMethod {
    public static void main(String[] args) {
        //方法重载体现多态
        A a = new A();
        //这里我们传入不同的参数，就会调用不同sum方法，就体现多态
        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){//和下面sum 构成重载
        return n1 + n2;
    }
    public int sum(int n1, int n2, int n3){
        return n1 + n2 + n3;
    }


    public void say() {
        System.out.println("A say() 方法被调用...");
    }
}

4.对象的多态(重难点)

一定要背下来的话：

  1. 一个对象的编译类型和运行类型可以不一致；
  2. 编译类型在定义对象时就确定了，不能改变；
  3. 运行类型是可以变化的；(看堆里面的对象)
  4. 编译类型看定义时 = 号的左边，运行类型看 = 号的右边；(编译看左，运行看右)

1.什么叫编译类型？什么叫运行类型呢？

1663688521016

可以让父类的一个引用指向子类的一个对象。

public class PolyObject {
    public static void main(String[] args) {
        //体验对象多态特点
        //animal 编译类型就是 Animal , 运行类型 Dog
        Animal animal = new Dog();
        //因为运行时 , 执行到该行时，animal运行类型是Dog,所以cry就是Dog的cry
        animal.cry(); //小狗汪汪叫

        //animal 编译类型 Animal,运行类型就是 Cat
        animal = new Cat();
        animal.cry(); //小猫喵喵叫
    }
}

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

public class Cat extends Animal {

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


public class Dog extends Animal {

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

5.多态细节讨论

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

  2. 多态的向上转型：

1663772457510

特点1：为什么不能调用子类中特有成员？因为在编译阶段，能调用哪些成员,是由编译类型来决定的。但是在运行时，又要从子类开始查找方法或者属性。

  1. 多态向下转型：

1663773502793

查看类中有的属性和方法

1663772582647

public class PolyDetail {
    public static void main(String[] args) {

        //向上转型: 父类的引用指向了子类的对象
        //语法：父类类型引用名 = new 子类类型();
        Animal animal = new Cat();
        Object obj = new Cat();//可以吗? 可以 Object 也是 Cat的父类

        //向上转型调用方法的规则如下:
        //(1)可以调用父类中的所有成员(需遵守访问权限)
        //(2)但是不能调用子类的特有的成员
        //(#)因为在编译阶段，能调用哪些成员,是由编译类型来决定的
        //animal.catchMouse();错误
        //(4)最终运行效果看子类(运行类型)的具体实现, 即调用方法时，按照从子类(运行类型)开始查找方法
        //，然后调用，规则我前面我们讲的方法调用规则一致。
        animal.eat();//猫吃鱼..
        animal.run();//跑
        animal.show();//hello,你好
        animal.sleep();//睡

        //老师希望，可以调用Cat的 catchMouse方法
        //多态的向下转型
        //(1)语法：子类类型 引用名 =(子类类型)父类引用;
        //问一个问题? cat 的编译类型 Cat,运行类型是 Cat
        Cat cat = (Cat) animal;
        cat.catchMouse();//猫抓老鼠
        //(2)要求父类的引用必须指向的是当前目标类型的对象
        Dog dog = (Dog) animal; //可以吗？编译时正确，运行时错误，抛出ClassCastException类型转换异常

        System.out.println("ok~~");
    }
}

public class Animal {
    String name = "动物";
    int age = 10;
    public void sleep(){
        System.out.println("睡");
    }
    public void run(){
        System.out.println("跑");
    }
    public void eat(){
        System.out.println("吃");
    }
    public void show(){
        System.out.println("hello,你好");
    }

}

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

public class Dog extends Animal {//Dog是Animal的子类
}
  1. 属性没有重写之说！属性的值看编译类型;(注意和方法的调用规则进行区分，因为方法是可以重写的)
public class PolyDetail02 {
    public static void main(String[] args) {
        //属性没有重写之说！属性的值看编译类型
        Base base = new Sub();//向上转型
        System.out.println(base.count);// ？ 看编译类型 10
        Sub sub = new Sub();
        System.out.println(sub.count);//?  20
    }
}

class Base { //父类
    int count = 10;//属性
}
class Sub extends Base {//子类
    int count = 20;//属性
}
  1. instanceOf 比较操作符，用于判断对象的运行类型是否为 XX 类型或 XX 类型的子类型
public class PolyDetail03 {
    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 编译类型 AA, 运行类型是BB
        //BB是AA子类
        AA aa = new BB();
        // true
        // true
        System.out.println(aa instanceof AA);
        System.out.println(aa instanceof BB);

        Object obj = new Object();
        System.out.println(obj instanceof AA);//false
        String str = "hello";
        //System.out.println(str instanceof AA);
        System.out.println(str instanceof Object);//true
    }
}

class AA {} //父类
class BB extends AA {}//子类

6.练习1

请说出下面的每条语言，哪些是正确的，哪些是错误的，为什么?

1663775756732

1663776138912

7.java 的动态绑定机制(非常非常重要)

Java 重要特性: 动态绑定机制

1.当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定;(方法的调用是从运行内存开始的)
2.当调用对象属性时，没有动态绑定机制，哪里声明，哪里使用。

public class DynamicBinding {
    public static void main(String[] args) {
        //a 的编译类型 A, 运行类型 B
        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() {//父类sum()
        return getI() + 10;//20 + 10
    }

    public int sum1() {//父类sum1()
        return i + 10;//10 + 10
    }

    public int getI() {//父类getI
        return i;
    }
}

class B extends A {//子类
    public int i = 20;

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

    public int getI() {//子类getI()
        return i;
    }

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

8.多态的应用-多态数组

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

应用实例:现有一个继承结构如下：要求创建 1 个 Person 对象、2 个 Student 对象和 2 个 Teacher 对象, 统一放在数组 中，并调用每个对象 say 方法.

应用实例升级：如何调用子类特有的方法，比如 Teacher 有一个 teach , Student 有一个 study 怎么调用？

使用instanceof来判断。

public class PloyArray {
    public static void main(String[] args) {
        //应用实例:现有一个继承结构如下：要求创建1个Person对象、
        // 2个Student 对象和2个Teacher对象, 统一放在数组中，并调用每个对象say方法

        Person[] persons = new Person[5];
        persons[0] = new Person("jack", 20);
        persons[1] = new Student("mary", 18, 100);
        persons[2] = new Student("smith", 19, 30.1);
        persons[3] = new Teacher("scott", 30, 20000);
        persons[4] = new Teacher("king", 50, 25000);

        //循环遍历多态数组，调用say
        for (int i = 0; i < persons.length; i++) {
            //老师提示: person[i] 编译类型是 Person ,运行类型是是根据实际情况有JVM来判断
            System.out.println(persons[i].say());//动态绑定机制
            //这里大家聪明. 使用 类型判断 + 向下转型.
            if(persons[i]  instanceof  Student) {//判断person[i] 的运行类型是不是Student
                Student student = (Student)persons[i];//向下转型
                student.study();
                //小伙伴也可以使用一条语句 ((Student)persons[i]).study();
            } else if(persons[i] instanceof  Teacher) {
                Teacher teacher = (Teacher)persons[i];
                teacher.teach();
            } else if(persons[i] instanceof  Person){
                //System.out.println("你的类型有误, 请自己检查...");
            } else {
                System.out.println("你的类型有误, 请自己检查...");
            }

        }
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 + "\t" + age;
    }
}
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;
    }
    //重写父类say

    @Override
    public String say() {
        return "学生 " + super.say() + " score=" + score;
    }
    //特有的方法
    public void study() {
        System.out.println("学生 " + getName() + " 正在学java...");
    }
}
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;
    }
    //写重写父类的say方法

    @Override
    public String say() {
        return "老师 " + super.say() + " salary=" + salary;
    }
    //特有方法
    public void teach() {
        System.out.println("老师 " + getName() + " 正在讲java课程...");
    }
}

9.多态的应用-多态参数

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

应用案例：

1663852761025

public class PloyParameter {
    public static void main(String[] args) {
        Worker tom = new Worker("tom", 2500);
        Manager milan = new Manager("milan", 5000, 200000);
        PloyParameter ployParameter = new PloyParameter();
        ployParameter.showEmpAnnual(tom);
        ployParameter.showEmpAnnual(milan);

        ployParameter.testWork(tom);
        ployParameter.testWork(milan);

    }

    //showEmpAnnual(Employee e)
    //实现获取任何员工对象的年工资,并在main方法中调用该方法 [e.getAnnual()]
    public void showEmpAnnual(Employee e) {
        System.out.println(e.getAnnual());//动态绑定机制.
    }
    //添加一个方法，testWork,如果是普通员工，则调用work方法，如果是经理，则调用manage方法
    public void testWork(Employee e) {
        if(e instanceof  Worker) {
            ((Worker) e).work();//有向下转型操作
        } else if(e instanceof Manager) {
            ((Manager) e).manage();//有向下转型操作
        } else {
            System.out.println("不做处理...");
        }
    }
}
public class Employee {
    private String name;
    private double salary;

    public Employee(String name, double salary) {
        this.name = name;
        this.salary = salary;
    }
    //得到年工资的方法
    public double getAnnual() {
        return 12 * salary;
    }

    public String getName() {
        return name;
    }

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

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }
}
public class Manager extends Employee{

    private double bonus;

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

    public double getBonus() {
        return bonus;
    }

    public void setBonus(double bonus) {
        this.bonus = bonus;
    }
    public void manage() {
        System.out.println("经理 " + getName() + " is managing");
    }
    //重写获取年薪方法
    @Override
    public double getAnnual() {
        return super.getAnnual() + bonus;
    }
}
public class Worker extends Employee {
    public Worker(String name, double salary) {
        super(name, salary);
    }
    public void work() {
        System.out.println("普通员工 " + getName() + " is working");
    }

    @Override
    public double getAnnual() { //因为普通员工没有其它收入，则直接调用父类方法
        return super.getAnnual();
    }
}
半路_出家ren
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
面向对象编程——多态
淘尽红尘几多娇的博客
12-31 260
面向对象三大特征之一：多态（方法和对象的多态）
面向对象的多态性
Tiffanya的博客
12-25 5995
学习目标： 1. Object类的toString()与equals(Object  obj)方法 2. 面向对象的多态性 3. 抽象类与接口   A.Object类      ·Object类是所有Java类的根基类(“祖先类”)      ·如果在类的声明中未使用extends关键字指明其基类，则        默认基类为Object类             a.to
java接口和抽象类
weixin_44110627的博客
04-14 3487
①定义一个动物接口Animal，包括一个eat（）方法表示吃。 interface Animal{ void eat(Food food); } ②定义一个猫类Cat，实现Animal接口，在eat（）方法中输入猫吃什么。 class Cat implements Animal{ public void eat(Food food){ System.out.println("猫吃"+ food.getName()); } } ③定义一个狗类 Dog， 实现 Animal 接口，在eato方法中
面向对象——多态
杨思默
05-27 1520
1. 多态概念        多态是面向对象程序设计（OOP）的一个重要特征，指同一个实体同时具有多种形式，即同一个对象，在不同时刻，代表的对象不一样，指的是对象的多种形态。        可以把不同的子类对象都当作父类来看，进而屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，统一调用标准。 多态的主要用途 1、提高程序的可扩展性； 2、降低系统耦合度； 3
【Java开发】面向对象编程：多态
我的主页
03-20 686
本期讲解:面向对象之封装继承多态中的多态，文字从多态的概念、多态的条件、重写、向上向下转型、多态的优缺点等来详细讲解多态，让我们继续学习面向对象的过程吧。
javascript 面向对象编程基础 多态
10-29
javascript 面向对象编程基础 多态 的实现方法说明，大家可以看下下面的代码。
C#中面向对象编程机制之多态学习笔记
09-03
主要介绍了C#中面向对象编程机制之多态学习笔记,本文总结了个人对多态的理解以及接口多态、继承多态等内容,并给出了代码示例,需要的朋友可以参考下
C#面向对象编程-多态习题[整理].pdf
10-11
C#面向对象编程-多态习题[整理].pdf
C语言实现对象编程之多态代码.rar
06-16
C语言实现对象编程之多态代码.rar 在C语言中还可以实现更深入的面向对象编程多态特性。例如：使用接口(interface)包含多个指向函数的指针，这样就可以实现操作的"多态性"。 在面向对象语言C++的实现上，使用了虚...
【Java】多态性
weixin_46437504的博客
07-25 519
多态性是一种允许使用一个界面来访问一类动作的特性，特定的动作可以由不同的具体情况而定（传入不同的参数）。多态性是发送消息给某个对象，让该对象自行决定响应何种行为。
面向对象三大特性之一——多态详解
weixin_59371851的博客
07-23 1687
哈喽，小伙伴们大家好。上一章我们一起学习了继承，今天我们继续来学习面向对象三大特性中的最后一个特性——多态。事不宜迟，快拿起小本本，跟我一起开始吧。一、多态的概念多态，顾名思义，也就是多种状态。通俗点说就是不同的对象去干同一件事情时会产生不同的状态。以买火车票为例，普通人买票就要付全款，学生买票就可以出半价，军人虽然不能优惠但是可以优先买票。放到我们程序中就是不同继承关系的类对象去调用同一个函数，会产生不同的状态。在了解多态的构成条件前，我们先来了解一个概念，虚函数。在同一个作用域。......
面向对象的三大特征之一多态
qq_28629389的博客
03-28 1557
1. 什么是多态 多态性是面向对象编程的又一个重要特征，它是指在父类中定义的属性和方法被子类继承之后，可以具有不同的数据类型或表现出不同的行为，这使得同一个属性或方法在父类及其各个子类中具有不同的含义。 对面向对象来说，多态分为编译时多态和运行时多态。其中编译时多态是静态的，主要是指方法的重载，它是根据参数列表的不同来区分不同的方法。通过编译之后会变成两个不同的方法，在运行时谈不上多态。而运行时多态是动态的，它是通过动态绑定来实现的，也就是大家通常所说的多态性。 简单的说就是 在通过父类来获取他名下继承
C语言--面向对象编程之多态
weixin_46185705的博客
03-27 3184
系列文章目录 C语言–面向对象编程之封装 C语言–面向对象编程之继承 文章目录系列文章目录前言一、多态是什么？二、使用步骤1.引入库2.读入数据总结 – 前言 C语言实现面向对象编程的第三篇，在前面两篇里面我们已经讨论了C语言实现面向对象的封装与继承，这篇我们了解，面向对象的最后一个特性，多态，顺便了解一下C++中的虚指针与虚表。 一、多态是什么？ 多态指的是能够根据对象的不同类型调用同一个接口，实现不同的功能。在C++中有一个叫做重载的功能，作用类似，比如下面的函数。 看例子： /*函数重载*/ in
void (* init)(void)；是什么？ 函数指针介绍
我是没有梦想的小白
12-14 5733
本文内容摘自C++ Primer Plus（第六版）P241 7.10函数指针。 1、引言     函数指针的本质是指针，该指针指向的对象为某一个函数。函数指针一般用作函数的参数。例如，现需要设计一个名为estimate的函数，用于估算编写指定行数代码所需要的时间，并且希望不同的程序源能够使用该函数。对于所有的用户来说，estimate函数中一部分代码应该是相同的，单数运行每个程序员自定义不同的算法来估计时间。为了实现这个目标，采用的机制是将用户自定义的算法函数的地址
面向对象 — 多态
m0_61410724的博客
06-12 1827
多态是面向对象程序设计（OOP）的一个重要特征，指同一个实体同时具有多种形式，即同一个对象，在不同时刻，代表的对象不一样，指的是对象的多种形态。方法或对象具有多种形态，是面向对象的第三大特征，多态是建立在封装和继承基础之上的。多态的前提是：1.继承。2.重写。多态的具体体现为：1.方法的多态（重写和重载就体现多态）。2.对象的多态。（1）本质：父类的引用指向了子类的对象。（2）语法：父类类型 引用名 = new 子类类型();（3）特点：编译类型看左边，运行类型看右边，可以调用父类类型中的所有成员（需要遵守
java面向对象程序设计多态
最新发布
05-27
Java是一种面向对象编程语言，多态是面向对象编程中的一个重要概念。多态是指同一个方法或操作在不同的对象上可以有不同的行为表现。在Java中，多态可以通过继承、接口和重载等方式来实现。 继承是Java中实现多态的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值