面向对象编程（oop）三大特征之三：多态

已于 2024-01-28 11:55:29 修改
阅读量963 收藏 24
点赞数 19
文章标签： java
于 2024-01-21 23:01:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/well_KD/article/details/135732748
版权

1. 多态的概念

1.1 多态的基本介绍

方法或对象具有多种形态。是面向对象的第三大特征，多态是建立在封装和继承基础之上的，可以说没有封装和继承，就不会有多态的概念

1.2 为什么需要多态

先看一个问题：

有三个类：Animal类、Food类和Master（主人）类

Animal类：通过Animal类创建多个动物子类：cat、Dog、Pig等（使用extends继承父类，下同）

Food类：通过Food类创建多种食物子类：Fish、Bone、Rice等

Master类：在这里定义多种方法，实现主人给每个动物喂食。（如下）


    //主任给小狗喂食 骨头
    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());
    }

这里只有两个方法，主人也只是喂了两个动物，如果动物多了起来，就要写好多好多的喂养方法。这就是传统方法的弊端：代码复用性不高，且不利于维护。

由此引出多态！

把上述传统的方法改成以下形式

public void feed(Animal animal, Food food) {
        System.out.println("主人 " + name + " 给 " + animal.getName() + " 吃 " + food.getName());
    }

 使用多态机制，可以统一的管理主人喂食的问题

 animal 编译类型是Animal,可以指向(接收)Animal子类的对象

 food 编译类型是Food,可以指向(接收)Food子类的对象

如此就可以在test类中通过调用一个方法，来实现给多个动物喂食的问题。

test类代码如下：

public static void main(String[] args) {
        Master tom = new Master("汤姆");
        Dog dog = new Dog("大黄");
        Bone bone = new Bone("骨头");

        tom.feed(dog,bone);

        Cat cat = new Cat("小花猫");
        Fish fish = new Fish("黄花鱼");
        System.out.println("===========");
        tom.feed(cat,fish);
    }

1.3 多态的具体体现

1.3.1 方法的多态

重写方法和重载方法就体现了多态，这里举例说明

1. 创建一个B类，写一个say()方法

2. 创建一个A类继承B类，在A类中写一个重载方法，写一个say()方法

3. 创建test类，在类中创建A和B对象，分别调用重写和重载方法

B类

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

A类

public class A extends B{
    //以下两个sum方法构成重载
    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()方法被调用...");
    }
}

test类

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();
    }

方法重载是同一个对象调用不同的方法（因为形参不同，构成了重载)，

方法重写是具有继承关系的两个类调用了一个方法，

二者都体现了多态性。

1.3.2 对象的多态

1.3.2.1 编译类型和运行类型

我们要先明白两个概念，在上文中也提到的编译类型和运行类型，编译类型可以简单的理解为是在终端命令行中写出的javac...  运行类型可以理解为是java...

先来看两行代码

A a = new A();
Animal animal = new Cat();

这两行代码=左边的A和Animal就是编译类型；=右边的A和Cat就是运行类型。

1.3.2.2 关于编译类型和运行类型的注意事项
  1. 一个对象的编译类型和运行类型可以不一致
  2. 编译类型在定义对象时，就确定了，不能改变
  3. 运行类型是可以变化的
  4. 编译类型看定义时 = 的左边，运行类型看 = 号的右边

解释：

1. 我们已经知道在Animal animal = new Cat();语句中，Animal是编译类型，Cat是运行类型。而在内存中我们对这句话的理解是Cat是我们在堆中创建的对象实例，Animal是父类的编译类型，animal 是父类的引用  指向了子类创建的Cat对象。这就是 "1" 编译类型和运行类型可以不一致的描述。当然它也可以一致。就是我们一般写的A a = new A();这样的语句。

2. 这句话就没那么多要解释的了，就是Animal这个编译类型在定义之后就是不可以改变的了。

3. 什么叫运行类型可以改变呢？看这一句，animal = new Dog(); 我们说过animal是父类的对象引用，在之前，我们把它指向了Cat对象，现在我们把它指向了Dog对象，而Cat和Dog在运行阶段又叫运行类型，所以我们说运行类型是可以改变的。

以上几条语句都体现了对象的多态性。仔细理解一下。

2. 多态的注意事项和使用细节

2.1 多态的前提

多态的前提是，两个对象（类）存在继承关系

2.2 多态的向上转型

  1. 本质：父类的引用指向了子类的对象
  2. 语法：父类类型  引用名 = new 子类类型()
  3. 特点：编译类型看=左边，运行类型看=右边
               可以调用父类中的所有成员（要遵守访问权限）
               不能调用子类中的特有方法
               最终实现效果看子类的具体实现

其实向上转型已经见过了，如下代码就是一个向上转型的语法。

Animal animal = new Cat();

为了讲清楚其特点，我们写一段代码来具体分析

案例概况：

1. 创建Animal类，定义几个方法

2.创建Cat类继承Animal类，定义一个特有方法

3. 创建test类，创建cat对象实例

Animal类：

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，你好");
    }
}

Cat类 ：

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

test类： 

public static void main(String[] args) {

        //向上转型：父类得引用指向了子类得对象
//        Cat cat = new Cat();
        Animal animal = new Cat();
        Object object = new Cat();

//      能调用的方法和不能调用的方法     
        animal.eat();//可以
//      animal.catchMouse();//不可以
       
        animal.eat();  //可以
        animal.run();  //可以
        animal.show();  //可以
        animal.sleep();  //可以
}

对应其特点，有两个如下问题：

question1：为什么不能调用子类中的特有方法？

我们在Cat类中定义了一个catchMouse()的特有方法，创建的对象也是子类对象，但是却不能调用这个特有方法。这是因为我们把Cat进行了向上转型，也就是编译类型由Cat变成了Animal，在编译阶段，能调用哪些成员是由编译类型决定的，编译器在Animal类中找不到catchMouse方法，所以会报错。

question2：最终的运行效果要看子类实现是什么意思？

这句话的意思是，调用方法时，要按照从子类（运行类型）开始查找方法。就是在jvm的内存布局中，由子类开始，一层一层的向上，往父类中寻找调用的方法，如果子类中有该方法，直接运行，若没有，向上找。

这两个问题总结出一句话：调用的时候看编译类型，运行的时候看运行类型。

2.3 多态的向下转型

我们在上面说到，向上转型不可以调用子类中特有的方法，那我们就要用这个方法怎么呢，这就引申了向下转型。我们看一下向下转型的概念和特点：

  1. 语法：子类类型  引用名  =  （子类类型）父类引用
  2. 只能强转父类的引用，不能强转父类的对象
  3. 要求父类的引用必须指向的是当前目标类型的对象
  4. 当向下转型后，可以调用子类类型中所有的成员

对以上特点进行一个解释：

2. 父类对象创建之后，它是堆中存在的一个实例，是不可以更改的，我们能改的只是它在栈中的引用类型。就像我们出生之后，这个人就是实实在在的一个人，不可能再变，但是我们的名字是可以更改的。

3. 我们在进行向下的强转之前，要求这个父类引用必须指向的子类对象的类型必须是当前目标类型。举例说：

我们要写一个Cat cat = （Cat）animal的强转语句，但是在这之前，animal这个父类引用指向的必须也是这个Cat类型的这个对象。（这里还是有问题，我不太明白是Cat类型的其他对象也可以还是必须是这个类型的同一个对象，我搞清楚再来更新，如果有小伙伴明白烦请评论区告知一声。）

 这时我们还没有成功的调用catchMouse方法，我们在test类中增加一些语句再去调用,为了方便，我删掉了调用父类方法的一些语句，可对照上文查看。

public static void main(String[] args) {

        //向上转型：父类得引用指向了子类得对象
//        Cat cat = new Cat();
        Animal animal = new Cat();
        Object object = new Cat();

//      能调用的方法和不能调用的方法     
        animal.eat();//可以
//      animal.catchMouse();//不可以
       
        Cat cat = (Cat) animal;
        cat.catchMouse();
}

这时，Cat cat = (Cat) animal;这条语句的编译类型是Cat，运行类型也是Cat。还是看 = 左右来看编译类型和运行类型。

2.3.1 instanceOf 比较操作符

instanceOf 比较操作符 用于判断对象的运行类型是否为XX类型或XX类型的子类型。

在运行过程中会出现强制类型转换异常。我们可以使用instanceof运算符来避免出现强制类型转换异常。

语法：System.out.println(bb instanceof BB);用来判断bb是不是BB类型或者其子类型，返回结果是true或flase。

我们举个例子来看一下

public class test {
    public static void main(String[] args) {
        B b = new B();
        System.out.println(b instanceof B);  //返回true
        System.out.println(b instanceof A);  //返回true

        //a的编译类型是A 运行类型是B
        //instanceof判断的是该对象的运行类型是否是该类型或者该类型的子类
        A a = new B();
        System.out.println(a instanceof B); //返回true
        System.out.println(a instanceof A); //返回true

        //举个例子
        Object obj = new Object();
        System.out.println(obj instanceof A);//这里返回的是false，因为obj的运行类型是Object，不是A类或者A的子类

    }
}

class A{ }
class B extends A{ }

要明确的是，在向下转型中，两个类之间要具有明确的父子关系时，才能强转，否则有会出现类型转换异常的报错（java.lang.ClassCastException）。而instanceof的作用在于此，判断某一个对象是否属于该类型或者该类型的子类型。从而进一步准确的进行强转。

2.4 向上类型和向下类型的总结：

  1. 向上转型和向下转型转的都是编译类型
  2. 向上转型语法：Person p = new Student()
  3. 向下转型语法：Student s = （Student）P;
  4. 区别：向上转型是在创建对象时就进行的，不是强转
               向下转型是强转，不需要创建一个新的对象，可以用instanceof来判断是否可以进行强转
  5. 转型后要注意编译阶段和运行阶段能够调用的方法和属性是哪个类的

2.5 java的动态绑定机制

概念：

  1. 当调用对象方法的时候，该方法会和该对象的内存地址（运行类型）绑定
  2. 当调用对象属性的时候，没有动态绑定机制。在哪声明，就在哪使用。

我们通过一段代码来解释这两句话。

代码解析：

  1. 创建一个A类，在类中定义属性 i 并赋值，创建sum()、sum1()和getI()等方法
  2. 创建一个B类继承A类，在类中定义属性 i 并赋值，创建sum()、sum1()和getI()等方法
  3. 在main方法中创建B类对象并向上转型为A类。
public class DynamicBingding {
    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(){
        return getI() + 10;
    }
    public int sum1(){
        return i + 10;
    }
    public int getI() {
        return i;
    }
}

class B extends A{
    public int i = 20;
    public int sum(){
        return i+ 20;
    }
    public int getI() {
        return i;
    }
    public int sum1(){
        return i+10;
    }
}

 以上代码运行过后输出的结果为40和30。

这时注释掉B类中的sum()方法，运行时就会去父类A中寻找sum()方法，但是A类中的sum()方法包含了getI()方法，可是A类和B类中都有getI方法，该调用哪个呢？这就体现了java的动态绑定机制。

当调用对象方法时，该方法会和该对象的内存地址（运行类型）绑定，我们创建的对象a，其运行类型是B类，所以在调用方法时，首先在B类中找方法，若B类中没有该方法，才会向上级父类中寻找。

这样在B类的getI()方法得到的I值是20，最终运行输出的值为30.

注释掉B类中的sum1()方法，运行时就会去父类A中寻找sum1()方法，A类中的sum1()方法包含了 i 这个属性，当调用对象属性的时候，没有动态绑定机制。在哪声明，就在哪使用。所以这里直接使用A类中的属性 i ，最终输出为20.

3. 多态的应用

3.1 多态数组

概念： 

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

应用实例：

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

Person类：

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;
    }
}

Teacher类：

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()+" 正在授课");
    }
}

Student类：

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()+" 正在听课");
    }
}

父子类的继承结构如上，下面主要看main方法中 多态数组是如何定义的，以及怎么调用各个对象的say方法

main方法

    public static void main(String[] args) {

        Person[] persons = new Person[5];
        persons[0] = new Person("jack",20);
        persons[1] = new Student("jack",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()); //动态绑定机制
        }

这时发现，say()方法是父子类共有的方法，那如何调用子类的特有方法呢？

在main方法中写出如下代码;

for (int i = 0; i < persons.length; i++) {
            //这时会想到向下转型，同时可以用instanceof来判断强转类型可不可以
            if (persons[i] instanceof 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();
                //上面两条语句等同于如下一条
                ((Teacher) persons[i]).teach();
            } else if (persons[i] instanceof Person) {
                //这里不写输出也不调用
                //因为Person也是一个类型，
                //如果不写这个判断条件，在运行至person[0]这条语句时，会输出下面的输出语句的内容
                //但是我们不需要对person类进行强壮（因为调用的是子类的特有方法），所以这里空着，不做处理就行
            } else {
                System.out.println("你的类型有误，请自己检查");
            }
        }

3.2 多态参数

概念：

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

在引入多态概念时，讲了一个主人喂动物的案例，其喂养方法就是一个多态参数。代码如下

public void feed(Animal animal, Food food) {
        System.out.println("主人 " + name + " 给 " + animal.getName() + " 吃 " + food.getName());
    }

这里的形参和实参就满足了多态参数的概念。

为理解透彻，再举一个案例：

案例要求：

  1. 定义员工类Employee，包含姓名和月工资[private]，以及计算年工资getAnnual的方法
  2. 普通员工类继承了员工，多了work方法
  3. 经理类继承了员工类，多了奖金bonus属性和管理manage方法
  4. 普通员工和经理类要求分别重写getAnnual方法
  5. 测试类中添加一个方法showEmpAnnual（Employee e），实现获取任何员工对象的年工资，并在main方法中调用该方法
  6. 测试类中添加一个方法，testWork，如果是普通员工，则调用work方法，如果是经理，则调用manage方法

Employee类:

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

    public Employee(String name, double salary) {
        this.name = name;
        this.salary = 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 double getAnnual(){
        return getSalary()*12;
    }
}

Worker类：

public class Worker extends Employee{

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

    public void work(){
        System.out.println("员工" + getName() + " 在工作");
    }

    //重写getAnnual方法
    @Override
    public double getAnnual() {
        return super.getAnnual();
    }
}

Manager类：

public class Manager extends Employee{
    private int bonus;

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

    public int getBonus() {
        return bonus;
    }

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

    public void manage(){
        System.out.println("经理"+getName()+" 正在管理工作");
    }

    //重写getAnnual方法
    @Override
    public double getAnnual() {
        return super.getAnnual() + bonus;
    }

}

测试类：

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);

    }
    public void showEmpAnnual(Employee e){
        System.out.println(e.getAnnual());
    }

    public void testWork(Employee e){
            if (e instanceof Worker){
                ((Worker)e).work();
            } else if (e instanceof Manager) {
                ((Manager)e).manage();
            }else {
                System.out.println("不能处理...");
            }
    }

}

还是比较简单的，说一下测试类的东西就好。在测试类中有两个方法，传的参数是Employee类型和其子类类型，用了动态绑定机制，看具体传入的参数e是什么类型就是什么类型。

多态的内容到这里结束，内容比较多，也比较粗糙，有哪些具体的问题后续会更新！

YOLO_Di
关注
  • 19
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Java面向对象编程三大特征 - 多态
qazqwerqaz的博客
04-14 196
Java面向对象编程三大特征 - 多态 本文关键字：Java、面向对象、三大特征、多态 多态是面向对象编程的三大特征之一，是面向对象思想的终极体现之一。在理解多态之前需要先掌握继承、重写、父类引用指向子类对象的相关概念，对继承还没有完全明白的同学可进传送门： Java面向对象编程三大特征 - 继承 。 一、抽象类 在继承中，我们已经了解了子父类的关系以及如何对子父类进行设计，如果已经存在多个实体类...
C++：多态（面向对象三大特征之一）
Breathmetoyou的博客
12-08 475
其实早就学完了，问就是忙于科研。 在编程语言和类型论中，多态（英语：polymorphism）指为不同数据类型的实体提供统一的接口。多态类型（英语：polymorphic type）可以将自身所支持的操作套用到其它类型的值上。（百度百科） 我的理解是：多态就是为了在 继承了父类的每个子类 中 重新定义 父类中的成员函数，使每个子类中的成员函数具有多态性。 多态 动态多态要满足以下条件： 1、有继承关系 2、子类重写父类的虚函数 动态多态的使用：父类的指针或引用指向子类的对象 下面举个栗子：
【OOP】多 态
懒羊羊的博客
04-28 860
学习目录一.多态的定义二.多态的作用三.多态的体现四.多态使用细节1.向上转型2.向下转型五.动态绑定机制六.多态数组 在没有接触多态以前，我们在主函数调用方法和属性时，一般是通过对象实例化相应的类来实现的，这十分复杂繁琐，特别是在以后如果遇到一个父类的子类非常的多，那工程量就十分的庞大！因此多态的作用与地位就显得十分的重要。 一.多态的定义 “一个接口，多种实现”——多态是一种性质 方法或对象具有多种形态。多态(polymorphism)指为不同数据类型的实体提供统一的接口。多态允许将子类的对象当作父类的
OOP 三大特征之多态（Polymorphism）
JavaEdge全是干货的技术号
10-10 3282
OOP三大特性最重要的：多态。 很多程序员虽然在用支持OOP的语言，但却从未用过多态。 只使用封装、继承的编程方式，称为基于对象（Object Based）编程 只有加入多态，才能称为OOP 没写过多态，就是没写过OO代码。 正是有了多态，软件设计才有更大弹性，更好拥抱变化。 如何理解多态？ 多态，即一个接口，多种形态。 一个draw方法，以正方形调用，则画正方形；以圆形调用，则画圆形： 继承的两种方式之一的实现继承，请尽可能用组合替代。而接口继承，主要是给多态用的。 因为重点在于继承体系的使用者，主
10 面向对象技术
10-23 1851
10 面向对象技术 面向对象（Object-Oriented，OO）方法是一种非常实用的软件开发方法，它已出现就受到软件技术人员的青睐，现在已经成为计算机科学研究的一个重要领域，并逐渐成为软件开发的一种主要方法。面向对象方法一客观世界中的对象为中心，其分析和设计思想符合人们的思维方式，分析和设计的结果与客观世界的实际比较接近，容易本人们所接受。 在面向对象方法中，...
深入理解OOP——多态
m0_46628950的博客
06-28 202
深入理解OOP——多态
OOP多态
qq_40760291的博客
03-01 261
###多态的定义(调用虚函数来实现多态) 多态(不同的对象完成相同的行为,展现不同的形态)是运行时多态通过虚函数来实现,就是通过定义基类的指针或引用来调用一个虚成员函数是会动态绑定,动态的绑定是指针或引用绑定的具体的对象,在运行是的时候,调用的方法是这个指针或引用所绑定的具体的对象的方法,而不是基类的方法.(通过定义基类的指针或引用来指向不同的对象,在运行的时候调用具体的虚函数的方法是这个基类指针或引用所指向的具体的对象的虚函数,而不是基类虚函数) ####注意事项: 1.虚函数必须是有定义,因为需要动态绑
C# 面向对象三大特性：封装、继承、多态
09-02
面向对象编程（Object-Oriented Programming，OOP）的核心理念在于模拟现实世界中的实体和行为，将复杂的系统拆分成易于理解和管理的独立对象。在C#中，面向对象的三大特性——封装、继承和多态，是实现这一目标的...
Python面向对象编程之继承与多态详解
09-20
面向对象编程（Object-Oriented Programming, OOP）是Python语言的核心特性之一，它允许开发者创建复杂的数据结构，模拟现实世界中的对象。继承和多态是OOP中的两个重要概念，它们极大地增强了代码的复用性和灵活性...
浅谈Java实现面向对象编程java oop
08-18
面向对象编程（OOP）是当前软件开发中最流行的编程范式之一。它具有多方面的吸引力，对管理人员、分析与设计人员和程序员都具有很高的实用价值。 一、对象的综述 对象是面向对象编程的核心概念。对象是一个实例，它...
oop 事件 委托 多态 继承
09-24
对oop 事件 委托 多态 继承作了比较简洁详尽的说明和介绍，希望能对你有帮助。
面向对象的三大特性
01-30
总结来说，面向对象的三大特性——封装、继承和多态，共同构建了面向对象编程的基石。理解并熟练运用这些特性，可以帮助开发者设计出更高效、更易于维护的代码，提高软件的可扩展性和可复用性。在线课第3节-面向对象...
Java OOP 第三章 多态
云哥的博客
03-30 2867
- 面向对象的三大特性：封装、继承、多态 - 封装是隐藏对象的属性和实现细节 - 将类的成员属性声明为私有的，同时提供公有的方法实现对该成员属性的存取操作 - 继承是软件可重用性的一种表现 - 新类可以在不增加自身代码的情况下，通过从现有的类中继承其属性和方法充实自身内容 - 多态是具有表现多种形态的能力的特征 - 在程序设计的术语中，意味着一个特定类型的变量可以引用不同类型的对象，自动地调用引用的对象的方法 - 即根据作用到的不同对象类型，响应不同的操作
OOP三大特性之多态
qq_40860565的博客
02-29 1113
1、多态是什么？ 多态是同一个行为具有多个不同表现形式或形态的能力。 2、Java实现多态必要条件 Java实现多态有三个必要条件：继承、重写、向上转型。 继承：在多态中必须存在有继承关系的子类和父类。 重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。 向上转型：在多态中需要将子类的引用赋给父类对象，只有这样该引用才能够具备技能调用父类的方法和子类的方法。 3、实例...
9.oop之多态
wu_intellect的博客
08-29 373
多态 1. 定义 同一个引用类型,使用不同的实例而执行的操作,实现多种形态。 创建一个对象以父类类型接收,因创建的实例不同,而表现出不同的形态,多态一定要在继承关系下的方法重写的情况下才能实现。 2.多态有两种体现方式 2.1、使用父类作为方法的形参实现多态 示例:通过食堂给不同的人打饭,方式和价格都不同 父类person类 /** * 父类-人类 * @author Administrator * */ public abstract class Person { String
OOP_多态
weixin_49833114的博客
03-28 505
一、多态的概念 生活中多态 同一个操作，由于条件不同，产生的结果不同。 程序中多态 同一个方法，不同的对象可以做出不同响应。 同一引用类型，使用不同实例（对象）而执行不同操作。 父类引用指向子类对象 1. 引用多态 父类引用指向本类对象 父类引用指向子类对象 2. 方法多态 创建本类对象时，调用的方法为本类方法 创建子类对象时，调用的方法为子类重写的方法或继承的方法 二、实现多态的三要素 有继承关系 重写 父类引用指向子类对象 三、引用类型转换 向上转型 父类型 引用变量名 = new 子类型();
OOP的三个核心本质之多态
04-18 795
向上的痛深刻剖析经典面试题之三：关于虚函数- -| 回首页 | 2005年索引 | - -乱弹深刻剖析经典面试题之四：OOP的三个核心本质之多态                                          OOP的三个核心本质是什么？     这是道基础中见思想的面试题，面试官爱问这个问题。不过关于OOP三个核心众多书籍似乎莫衷一是。《
OOP思想--多态
zhuoya_的博客
05-12 498
本篇的目录*************************************      静多态                                    **      动多态                                    **      多态产生的条件                       **       抽象类                ...
JAVA—OOP之多态
我真是小学生的博客
10-22 938
JAVA—OOP之多态   水，汽，冰就是一个物体在不同条件下的不同种状态   1、什么是多态？ A：生活中的多态 就好比在学校没老师上自习课一样，此时每种人都有不同的状态，有的认真做作业，有的玩手机，有的讲小话，有的睡觉。当听到老师来了的这个消息的时候，每个人都会有不同的反应，有的无所谓，有的吓尿了，有的吓屎了等等等。 B：程序中的多态 同一个引用类型，使用不同的实例而执行不同操
面向对象的三大特征，并解释其特点
最新发布
07-20
面向对象编程（OOP）有三个主要特征：封装、继承和多态。 1. 封装（Encapsulation）：封装是将数据和方法封装在一个单元内部，对外部隐藏其内部实现细节的机制。通过将相关的数据和方法组织在一起，可以提高代码的可维护性和可重用性。封装还可以实现数据的访问控制，通过定义公共接口和私有属性，可以限制外部对内部数据的直接访问。 2. 继承（Inheritance）：继承是指一个类可以从另一个类继承属性和方法。通过继承，可以构建类之间的层次结构，并实现代码的重用。子类可以继承父类的属性和方法，并且可以在此基础上进行扩展或修改。继承还可以实现多态性。 3. 多态（Polymorphism）：多态是指同一类型的对象在不同的情况下可以表现出不同的行为。多态性允许使用基类类型引用指向派生类对象，从而在运行时动态确定调用的具体方法。多态性提高了代码的灵活性和可扩展性，使得程序更加易于维护和扩展。 这三个特征是面向对象编程的核心概念，它们相互关联并相互作用，共同提供了一种灵活、可重用和易于维护的编程范式。通过封装、继承和多态，可以更好地组织和管理代码，提高代码的可读性、可扩展性和可维护性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值