精华内容
下载资源
问答
  • 封装、继承、多态 通俗理解

    千次阅读 2007-05-31 16:26:00
    比较抽象,只是一种概念,刚开始学时候无需太过于深究,如果要你一... 继承,先说说我对类的理解,类起到作用有:分类(你所用某个类创建的对象实际上该类个案)和模板作用,那么继承则起到了对类再次分类
    比较抽象,只是一种概念,刚开始学的时候无需太过于深究,如果要你一上来学JAVA就理解这些东西,有点牵强,你所要做的就是至少看到代码知道这个用到的是什么。 

    封装的概念好比一辆汽车,你学开车的时候只需学会诸如踩油门、刹车,转方向盘即可,无需去了解它的发动机是如何发动。

    继承,先说说我对类的理解,类起到的作用有:分类(你所用某个类创建的对象实际上该类的个案)和模板的作用,那么继承则起到了对类再次分类的作用,比如,有个类“动物”,“哺乳动物”继承“动物”,再往下“马”又继承了“哺乳动物”这个类。在这里,我们从下往上讲,首先,我们把某种东西划分出来,叫做“马”(当然还有“牛”,“鱼”等等),接着,我们发现,“马”,“羊”等还有很多共同的特点,于是,我们再次划分出了“哺乳动物”这个类,再次分类,我们则有了“动物”。但在实际开发中,我们一般是从上往下定义的,即先有了“动物”,再有“哺乳动物”,最后有“马”。

    多态,正如上面朋友所说一重写,二重载。用汉字来打个比方,比如“开”这个字,在不同的时候各有的意思,比如“开门”,“开窗”,甚至有“开车”,“开饭”等,具有相同名称但操作不同。具体的实现我就不累述了。

    说说接口吧,在JAVA不支持多继承的,实际上接口起到了类似多继承的作用,一个类只能继承另一个类(或抽象类)但可以实现多个接口。打个比方,“张三”,他是一个“人”,因此他继承了“人”;与此同时,他是一个“司机”,他的平时行为还有“开车”,很显然,这并不能从“人”这个类里继承下来。怎么办?JAVA里只支持单继承,这个时候,接口就起到了作用,它定义了“司机”这个接口,“张三”实现了它,因此,他会开车了。 
    展开全文
  • python中继承和多态?继承:在已有类基础上创建新类,这其中一种做法就是让一...如何用通俗的方式理解python函数之间继承,多态python本来就是多态的 python变量是没有类型,只有指向的对象是有类型,...

    python中的继承和多态?

    继承:在已有类的基础上创建新类,这其中的一种做法就是让一个类从另一个类那里将属性和方法直接继承下来,从而减少重复代码的编写。 1.提供继承信息的小编们称之为父类,也叫超类或基类;2.得到继承信息的小编们称之为子类,也叫派生类或衍生类。

    如何用通俗的方式理解python函数之间的继承,多态python本来就是多态的 python的变量是没有类型的,只有指向的对象是有类型的,所有方法的调用都是调用对象的方法。

    Python 的多态继承怎么理解简单?

    47,Python面向对象中的继承有什么特点单继承与多继承区别: Python同时支持单继承与多继承,当只有一个父类时为单继承,当存在多个父类时为多继承。 继承的性质特征: 子类会继承父类的所有的属性和方法,子类也可以覆盖父类同名的变量和方法。

    面向对象的三个特点:继承、封装和多态。请各位大各位大神,请帮帮忙,用代码示例分别解释一下继承、封装和多态,这样更面向对象的程序设计的基础是类。 一个类中的(私有的或保护的)数据成员,本类的成员函数可以直接访问,而不允许类外函数直接访问(但可以通过该类提供的公有函数访问),这就是封装性。 一个类可以派生子类(派生类)。

    python中到底“多态”是什么。。。

    Python是一种纯粹的面向对象语言。面向对象编程中的四大特征分别是:抽象、封装、继承和多态。多态根据上下文,对象可以采用多种形式。程序将确定该对象每次执行所需的含义或用法,从而减少了重复代码。 小编国有句俗语:“龙生九子,各有不同”。

    面向对象的三个特点:封装、继承和多态。请各位大请各位大神分别用代码示例解释一下封装、继承和多态这三个特点,非常感一个类中的(私有的或保护的)数据成员,本类的成员函数可以访问,而不允许类外函数访问,这就是封装性。 子类自动具有父类的特征,这就是继承性。 通过基类(指针或引用)可以调用各个派生类的成员函数以实现不同的功能,这就是多态性。

    python面向对象编程题?

    ,python小白完全不知从何下手,分享助大神。小编再也不会奋不顾身的去爱一个人了,哪怕是你。

    父类省份,子类地级城市继承父类 地级城市属性:姓名、商品数量、基金数目 地级城市方法:买,对应功能1;卖,对应功能2 主方法中包含变量:自己(qinshihuang),周边市供应商(liubang),买家(hanxin),利润期望 随机变量是商品销售数 初始状态是悲伤是一杯苦茶时间就是水把所有的悲伤越冲越淡!太想念一个人的心情说说

    Python面向对象编程题

    1.定义一个表示时间的类Time,它提供下面操作: a)Time( hours, minutes, class Time: def __init__(self, hours, minutes, seconds): self.__hours = hours self.__minutes = minutes self.__seconds = seconds def hours(self): return self.__hours def minutes(self): return self.__minutes def seconds(self): re如果没有遇见你,小编本来是可以忍受那些孤独的。

    编程语言中的,封装,继承,多态 怎么解释?其实小编很满足了不是吗?小编至少知道了你的名字,你的电话,听过你的声音,看过你的眼睛,至少你知道小编喜欢你。尽管小编很难过,小编还是会喜欢你。

    小编明天要去面试 内部消息有这道题 有什么好的答案 回答的简单通俗易懂点网上能找到的都是说的严谨的,如果没理解真没办法一两句说清楚,封装提高了代码可重用性可维扩性,写方法、类都是封装;继承是然将两个或两个以为有共性的成员拿出来写成基类,其根本目的还是提高可重用性。

    展开全文
  • 关于多态的理解

    2020-03-20 11:24:30
    关于多态理解1....多态也称作动态绑定(dynamic binding),是指在执行期间判断所引用对象的实际类型,根据其实际的类型调用其相应的方法。 通俗地讲,只通过父类就能够引用不同的子类,这就是多态,我们只有...

    1. 什么是多态?

    多态是指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。多态也称作动态绑定(dynamic binding),是指在执行期间判断所引用对象的实际类型,根据其实际的类型调用其相应的方法。
    

    通俗地讲,只通过父类就能够引用不同的子类,这就是多态,我们只有在运行的时候才会知道引用变量所指向的具体实例对象。

    2.使用多态的前提

    Java 实现多态有三个必要条件:继承、重写和向上转型(即父类引用指向子类对象)。
    只有满足上述三个条件,才能够在同一个继承结构中使用统一的逻辑实现代码处理不同的对象,从而达到执行不同的行为。

    3.通过代码来理解多态的特性

    package demo02;
    
    public class Test {
        public static void main(String[] args) {
            //实例化Animal类的对象
            //animal是父类的引用指向的是本类的对象
            Animal  animal = new Animal();
    
            //实例化Dog类的对象
            //dog是子类的引用指向的是本类的对象
            Dog dog = new Dog();
    
            //使用多态
            //a是父类的引用指向的是子类的对象
            Animal a = new Dog();
    
            animal.bark();
            dog.bark();
            a.bark();
            
            //a.dogType = "哈士奇";
            // 如果这样使用的话会报编译错误,Error:(18, 10) java: 找不到符号dogType
            //a.eat();Error:(20, 10) java: 找不到符号方法 eat()
            
            a.age=10;
            System.out.println(a.age);
            a.work();
    
        }
    }
    
    class Animal{
        int age;//动物的名字
        public void bark(){
            System.out.println("我在叫");
        }
        
         public void play(){
            System.out.println("我在玩耍");
        }
    }
    
    class Dog extends Animal{
        String dogType;
        public void bark(){
            System.out.println("汪汪汪");
        }
        public void eat(){
            System.out.println("吃骨头");
        }
    }
    
    
    运行结果:
            我在叫
    		汪汪汪
    		汪汪汪
    		10
    		我在玩耍
    		
    在这个代码中,创建了Animal类、Dog类以及测试类Test,并且Animal类和Dog类构成了继承关系(Dog类继承了Animal类),在Test类中,创建了animal父类的引用指向本类的对象,创建了dog子类的引用指向本类的对象,也创建了父类引用指向子类对象的变量a。  
    

    我们使用这三个引用变量分别调用他们的bark方法,运行结果如上所示,我们可以看出,animal和dog运行的都是他们本类的bark方法,而在a这个引用变量调用的是子类的bark方法。
    由此我们可以得出第一条结论:
    在使用多态时,子类方法完成了对父类方法的重写后,父类引用会去调用子类的方法而不去调用父类的方法

    接着,a引用去访问子类的dogType的属性、使用子类的eat方法的时候,在编译时会报错。
    由此我们可以得出第二条结论:
    在使用多态时,父类引用不能访问和使用只有子类拥有的属性和方法(也就是父类没有的属性和方法)

    最后,访问父类拥有的age属性的时候,是可以正常运行的。a引用调用了父类Animal特有的方法play(在子类并没有覆盖重写),也是可以成功运行的,运行结果如上所示。
    由此我们可以得出第三条结论:
    在使用多态时,父类引用可以访问父类特有的属性、使用父类特有的方法。

    总结

    对于成员变量:编译看左边(父类),运行看左边(子类)
    对于成员方法:编译看左边(父类),运行看右边(子类)

    展开全文
  • 实例通俗理解Java中的多态 文章目录多态定义总结多态存在的三个必要条件多态的作用多态注意点多态应用场景 多态定义 不同类的对象(有共同的父类)面对同一消息(消息可对应理解为方法)做出不同的响应。看一个简单...

    实例通俗理解Java中的多态

    多态定义

    不同类的对象(有共同的父类)面对同一消息(消息可对应理解为方法)做出不同的响应。看一个简单的例子:

    定义父类:Peson.java,方法:eatdinner

    public class Person {
        public Person(){}
        public void eatdinner(){
            System.out.println("a person is eatting dinner");
        }
    }
    

    定义子类:Student.java,方法:eatdinner,继承自Person并重写了父类方法

    public class Student extends Person{
        public Student(){}
        @Override
        public void eatdinner() {
            System.out.println("a student is eatting dinner");
        }
    }
    

    定义子类:teacher.java,方法:eatdinner,继承自Person并重写了父类方法

    public class Teacher extends Person {
        public Teacher(){}
        @Override
        public void eatdinner() {
            System.out.println("a teacher is eatting dinner");
        }
    }
    

    测试多态效果:test.java,注意看注释

    public class test {
        public static void  main(String[] args){
            Person Pstudent = new Student();//Java中的向上转型:父类(Person类)引用指向子类实例对象(Student对象)
            Person Pteacher = new Teacher();//Java中的向上转型:父类(Person类)引用指向子类实例对象(Teacher对象)
            Pstudent.eatdinner();
            Pteacher.eatdinner();//不同对象面对同一消息(函数)做出的不同反应,注意看以下运行结果
        }
    }
    

    不清楚对象之间的向上转型和向下转型的区别请戳这里,另附上基本数据类型的转型

    运行结果:

    a student is eatting dinner

    a teacher is eatting dinner

    可以看出不同对象面对同一消息(函数)做出的不同反应,注意看以上运行结果。

    总结多态存在的三个必要条件

    • 继承

      Teacher和Student均继承了父类Person

    • 重写

      Teacher和Student均重写了Person类中的eatdineer

    • 向上转型

      父类引用指向子类实例对象

    多态的作用

    解耦合,消除类与类之间的关系,结合场景理解:比如面对一个类中有一些功能类似的方法,像实现一个人打球的方法,如果一个人会打乒乓球,篮球,羽毛球,如果不用多态,实现如下:

    • 非多态版本:

    既然是打球,首先得有个球吧,那定义三个球类吧,篮球乒乓球羽毛球三个类,球有什么方法,那只有被打了,并实现方法played

    定义Basketball.java

    public class Basketball {
        public void played(){
            System.out.println("打会儿篮球");
        }
    }
    

    定义Badminton.java

    //羽毛球
    public class Badminton {
        public void played(){
            System.out.println("打会儿羽毛球");
        }
    }
    

    定义Tabletennis

    public class Tabletennis {
        public void played(){
            System.out.println("打会儿乒乓球");
        }
    }
    

    打球得人来打吧,那再定义个person类

    person.java

    public class person {
        //重载实现打三种球
        public void playball(Basketball basketball){
            basketball.played();
        }
        public void playball(Tabletennis tabletennis){
            tabletennis.played();
        }
        public void playball(Badminton badminton) {
            badminton.played();
        }
    }
    

    实现打球playball功能,当然是你给我传什么球person打什么球,但是每个球的类型都不一样,那怎么办?所以得重载的方法实现三个打球的方法,分别传不同的球给人,刚好完美解决这个问题。写demo测试一下:

    public class demotest {
        public static void main(String[] args){
            //实例化人、篮球、羽毛球、乒乓球
            person p1 = new person();
            Basketball basketball = new Basketball();
            Badminton badminton  = new Badminton();
            Tabletennis tabletennis = new Tabletennis();
            //球传给人,开始打球
            p1.playball(basketball);
            p1.playball(badminton);
            p1.playball(tabletennis);
        }
    }
    

    输出结果如下,可以看出实现了这三种功能:

    打会儿篮球

    打会儿羽毛球

    打会儿乒乓球

    那么问题来了,如果现在又学会了足球呢?除了实现一个足球的类之外,还得在person类里加一个打足球playball方法,person类修改如下:

    public class person {
        public void playball(Basketball basketball){
            basketball.played();
        }
        public void playball(Tabletennis tabletennis){
            tabletennis.played();
        }
        public void playball(Badminton badminton) {
            badminton.played();
        }
        public void playball(Football football) {
            football.played();
        }
    }
    

    以后再添加一种球,就得修改一下person,十分麻烦,有没有一种方法不用修改person类,对于这种打球的功能,实现一个统一的方法,当你传入不同的球,能让person自己打不同的球。这不就是多态吗?不同类的对象(各种球)面对同一消息(打球的函数)做出不同的响应(实现打不同的球)。那来写一下吧。首先实现所有球的父类Ball.java

    • 多态版本
    public class Ball {
        public void played(){
            System.out.println("打会儿球吧");
        }
    }
    

    然后分别实现篮球、羽毛球、乒乓球类,都继承了Ball类

    public class Basketball extends Ball {
        @Override
        public void played(){
            System.out.println("打会儿篮球");
        }
    }
    public class Badminton extends Ball{
        @Override
        public void played(){
            System.out.println("打会儿羽毛球");
        }
    }
    public class Tabletennis extends Ball {
        @Override
        public void played(){
            System.out.println("打会儿乒乓球");
        }
    }
    

    实现person类:

    public class person {
        public void playball(Ball ball){
            ball.played();
        }
    }
    

    测试:

    public class demotest1 {    
        public static void main(String[] args){
            person p1 = new person();
            Ball basketball = new Basketball();//父类(ball)引用指向子类实例(basketball)
            Ball badminton  = new Badminton();
            Ball tabletennis = new Tabletennis();
            p1.playball(basketball);
            p1.playball(badminton);
            p1.playball(tabletennis);
        }
    }
    

    结果:

    打会儿篮球

    打会儿羽毛球

    打会儿乒乓球

    如果此刻再来了一个足球或者其他什么球,也没有关系,只要让其继承了Ball父类,然后重写了父类中的方法就可以作为参数传入到person类中的playball方法中,在实际操作中,Ball父类更多采用的接口而不是类,因为其中定义的方法并没有用到,都是调用子类中重写的方法。

    多态注意点

    三个条件:继承;重写;向上转型。

    向上转型后,父类引用------>子类实例,方法和变量的该调用父类还是子类需要注意,和普通的继承关系不一样,具体总结如下:

    类型 调用方式
    同名静态方法 调用父类的
    同名成员方法 调用子类的
    同名静态成员 调用父类的
    同名成员成员 调用父类的

    多态应用场景

    个人理解,很多向上转型的场景其实都用到多态了,这里需要理解一下,首先向上转型,肯定是父类引用----->子类实例,这里其实已经有了上面提出的多态两个条件了,继承和向上转型,然后调用一个子类方法,很容易就满足了多态的条件。那么多态有哪些具体场景:

    • 用于方法的参数中

      上述的打球就是一个很好的例子

    • 用于方法的返回类型中

      接着以打球举个例子,上述的basketball、tabletennis等对象都是通过new出来的,对于这些有共同父类的对象,能不能用同一种方法来实现实例化对象,而不是直接new,在主程序中直接new,如果别人没有看过你的basketball、tabletennis等类的源码不会觉得这些球类之间有共同的父类的,个人理解,这写法都是为了方便理解。

    //以前写法
    public class demotest1 {
        public static void main(String[] args){
            person p1 = new person();
            Ball basketball = new Basketball();
            Ball badminton  = new Badminton();
            Ball tabletennis = new Tabletennis();
            p1.playball(basketball);
            p1.playball(badminton);
            p1.playball(tabletennis);
        }
    }
    
    //工厂类写法
    public class BallFactoryTest {
        public static void main(String[] args){
            Ball ball1 = BallFactoryDemo.Ballproduce("basketball");
            Ball ball2 = BallFactoryDemo.Ballproduce("badminton");
            Ball ball3 = BallFactoryDemo.Ballproduce("tabletennis");
            person p1 = new person();
            p1.playball(ball1);
            p1.playball(ball2);
            p1.playball(ball3);
        }
    }
    

    那么BallFactoryDemo是个什么呢,不用想的很复杂,其实就是个if-else嵌套写的,代码如下:

    package BallFactory;
    public class BallFactoryDemo {
        //用Ball父类(方法返回类型为Ball)来接收子类实例对象(实际返回子类实例)----->多态
        public static Ball Ballproduce(String ball){
            if (ball.equals("basketball")){
                return new Basketball();
            }else if (ball.equals("badminton")){
                return new Badminton();
            }
            else if (ball.equals("tabletennis")){
                return new Tabletennis();
            }
            else{
                System.out.println("no ball");
                return null;
            }
        }
    }
    

    可以看出BallFactoryDemo类就像一个Ball工厂一样,可以生产出各种不同的Ball对象,其返回值可以是Ball的各种子类,这一点就很好的利用到了多态,使用父类引用接收了子类实例,而上面的BallFactoryDemo类实际上就是个工厂类,这就是传说中设计模式中的工厂模式,是不是不知不觉就get了工厂模式和多态知识点。


    作者:@caiyu@Email:347632365@qq.com

    展开全文
  • C++ 多态意味着调用成员函数时,会根据调用函数的对象的类型来执行不同的函数。 通俗来讲,就是有两个类,是父类子类的关系,这两个类里面都有一个函数并且名字、参数、返回值都一样,然后我们通过调用函数来实现...
  • 多态是Java面向对象的一个非常重要的机制,多态也被称为动态绑定,该机制是用于增强可扩展性而提出的。 多态的必要条件: 1.存在继承关系 2.对父类中的方法进行了重写 3.调用方法时,形参为父类引用 在实际运行...
  • 面向对象是把一组数据结构和处理他们的方法组成对象,...今天整理了一下,彻底搞懂了什么叫面向对象,下面用通俗的话详细讲解面向对象的相关概念。注意这里提到的几个关键词:数据、方法、对象、类、封装、继承、多...
  • 多态是码农们必须要理解理解的一个基本思想, 是面向对象的基石。   但是很多人(包括我)第一次接触多态时都会困惑: 这东西有什么用处?   多态的例子在Java里非常简单,每个初学者都会遇到:      ...
  • 2、通俗理解:在同一种方法中,传入不同参数,得到不同结果,是为多态。 3、实现:(1)不同子类对父类同一种方法给出不同实现 (2)夫类型引用指向子类实例对象 上代码 首先,使用构造函数传参(四个类...
  • 浅谈对多态的理解多态是C++中面向对象设计里一个重要内容。所谓多态是指一个实体同时具有多种形式,通俗来讲就是同一个操作对于不同的对象,可以有不同结果。
  • 代码如下,猫狗继承自动物类,分别创建猫狗实例,然后用猫狗实例来创建一个lady的对象。...据说这个就是多态的简单例子,求解一个比较通俗易懂讲解!谢谢!public class TestPolymoph {public static void mai...
  • 面向对象多态

    2013-03-22 21:56:55
    其按照字面的意思即”多种状态”,在面向对象语言中通俗的可以理解为“一个接口多种实现”,即允许你将父对象设置成为和一个或更多的他的子对象相等的技术,赋值之后,父对象就可以根据当前赋值给它的子对象的特性以...
  • 多态(polymorphism = poly(复数) + morph(形态) + ism)定义:同一操作作用于不同的对象上面,可以产生不同解释和执行结果。 文字含义很容易理解,但往往在需要使用时却想不起它。真正想要灵活使用一个设计...
  • 面向对象---理解多态

    2019-03-25 20:22:11
    多态通俗来说,就是多种形态,完成某个行为,当不同的对象去完成某个行为时会产生不同状态。二、多态定义及实现 1、多态定义构成条件 多态是在不同继承关系对象,去调用同一函数,产生了不同行为。 例如...
  • 通俗理解,只要是 python 中可以进行操作任何东西,都可以称为 “对象” 整数,浮点数 字符串 元组 字典 列表 通过自定义类创建的对象 在调用各种函数时候需要进行参数传递,其实传递参数可以看成是...
  • 多态的理解(摘抄)

    2008-10-23 15:07:00
    而在面向对象编程中,多态是指两个或多个属于不同类型的对象,对同一个消息(方法调用)做出不同响应能力。 举个通俗的例子,如果我们要求三种人------外科医生、发型师和演员------“cut!”,则 1、外科医生会在...
  • JAVA多态理解

    2021-02-08 21:27:57
    通俗的讲是指事物有多种状态。比如:水在通常情况下是液态,但在外界环境变化时可能会是固态冰或者气态水蒸气。 Java中多态三个步鄹 1.要有继承关系 2.要有方法重写 3.要有父类应用指向子类对象 代码案例:动物类 1....
  • (1)派生类对象的地址可以赋值给基类指针。对于通过基类指针调用基类和派生类中都有的同名、同参数表的虚函数的语句,编译时并不确定要执行的是基类还是派生类的虚函数;而当程序运行到该语句时,如果基类指针指向...
  • 多态通俗的讲:是指父类引用指向 了子类的对象; 比如:Animal(动物)类,Dog(狗),狗属于动物,所以Dog extends Animal 一般Animal animal = new Dog(); 父类引用animal指向子类对象Dog();就属于多态, ...
  • C++中多态理解

    2020-06-16 17:15:51
    一、多态的概念 ...多态是在不同继承关系对象,去调用同一函数,产生了不同行为。 形成条件: (1)子类要继承父类。 (2)子类要重写父类虚函数。 (3)要用父类指针或应用调用虚函数。 ...
  • 多态即多种形态,通俗来讲就像一个人有不同身份,比如说人:生物,地球人,中国人,学生,等等。 使用多态的前提:1.必须有子父类关系 (必须有继承)2.必须有方法重写 多态在java中表现形式:父类类型 变量名 = ...
  • 什么是多态对象的多种形态,一个对象被多种称谓 表现方面: 引用多态(继承或接口实现)// 父类的引用可以指向本类的对象; Animal obj1 = new Animal(); // 父类的引用可以指向子类的对象; Animal obj2 = new ...
  • 一、面向对象思想概述 在这之前,我们先来讲述面向过程。 面向过程:明确一个目的后,一步步亲自参与其中去实现它,这就是面向过程 举例:洗衣服:换下脏衣服----盛水----浸泡----...1.面向对象的特征: 封装(encaps...
  • 我个人理解的多态就是一些功能不同的函数可以使用统一函数名,也就是一个函数名可以调用内容不同功能不同的函数。 比如,将父对象设置成为更多的他的子对象相等的功能,赋值之后,父对象就可以根据当前赋值给它的子...
  • 在计算机科学中,它描述了可以通过相同的接口访问不同类型的对象的概念。每种类型都可以提供自己独立的接口实现。 通俗一点来说,同一类型的对象调用同一个方法,表现出不同行为,就是多态**。 java中的多态 /** ...
  • 理解多态性,首先要知道什么是“向上转型”。转型是在继承基础上而言,继承...通俗地说就是是将子类对象转为父类对象。此处父类对象可以是接口。我定义了一个子类Cat,它继承了Animal类,那么后者就是前者是父...
  • 多态

    2020-01-15 14:10:59
    多态也称作动态绑定(dynamic binding),是指在执行期间判断所引用对象的实际类型,根据其实际的类型调用其相应的方法。 通俗地讲,只通过父类就能够引用不同的子类,这就是多态,我们只有在运行的时候才会知道引用...

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 126
精华内容 50
关键字:

对象的多态通俗理解