我理解的“多态”“：
1.父类中的行为（函数）被若干子类继承。也就是说，子类与父类有共同的同名行为。
2.对子类共有同名函数进行特殊化修改复写，形成同名但是不同内容的行为。
3.当对父类中某个共有的同名函数进行调用（向函数发送参数）的时候，会根据参数的不同，父类会跳转或调用它的某个相应的子类的同名函数，作出不同响应。
11 个解决方案
#1
[重写，与重载理解好了，理解多态不难,
我的理解有什么错误没有？哪里需要修正？, 1.同一类型的引用指向不同的对象时，
------行为的多态:重写的方法实现多态
2.同一个对象被造型为不同的类型时，有不同的功能。。。
-----对象的多态。, 理解的很好呀，有些时候概念理解透彻需要通过实际项目中的应用，比如我们为什么要知道多态，为什么这样子的概念就是多态，反而这些是我们实践的结果。举个例子，一个项目中用到了一个支付功能，这样就需要调用第三方接口，比如银行，支付宝，微信等
那么我们怎么办才能让这三家接口对于我们来说是同样的，这就需要好好的设计定义一个统一的接口，然后有三个类分别实现这个方法，对于调用层而言就只知道一个方法传什么参数就可以，其他的都不用管。
我举这个简单例子就是为了让你知道概念来自于实际应用。, (1)同一个对象，在不同时刻表现出来的不同状态。
举例：水(水,冰,水蒸气)
猫(猫,动物)
(2)前提：
A:有继承或者实现关系。
B:有方法的重写。
C:有父类(接口)的引用指向子类对象。
(3)多态中的成员使用特点：
Fu fz = new Zi();
多态时，所有表现形式都是父类的表现形式，
只有调用方法时，运行的是子类重写的方法
A:成员变量
编译看左边，运行看左边。
B:成员方法
编译看左边，运行看右边。
(4)多态的好处及弊端：
A:好处
提高了程序可维护下和可扩展性。
B:弊端
不能使用子类特有内容。
要想使用，要么向下转型，要么重新创建子类对象。, 从C语言的数据结构上来理解。
多态，无论如何，最终还是对一个函数的调用。这个函数是一个函数指针，它有存储空间。
这个存储空间的值，指向不同的函数，就会体现为调用不同的函数。
而这个存储空间的值，怎么确定呢？
一个对象上的函数，如果标记为虚函数，那么会在类对象的存储空间里分配一个函数指针。
创建类对象时，这个函数指针必然会有一个确定的值。
当子函数覆盖override这个函数时，子类上的同名函数的地址，会写到上述的函数指针上。---这时，在基类调用改函数时，都会调用子类定义的函数。
--这个是 子类上体现的多态。
至于参数不同的多态，这个在编译器内部就处理掉了。参数不同，函数就不同，编译器会根据代码，准确知道应该使用那个函数，这种多态在C++里才有意义，C++里面是通过替换函数名来实现的。
接口上的多态更普遍。一个类实现了一些接口，依照我的理解，应该是建立了一个：接口-函数地址表，这个表在C++里面是静态的，通过.h文件来定义，在Java,C#里面则不一定了，具体没有深入研究，这里的坑有点深。但接口函数+接口实现+接口虚函数，这些条件综合考虑，就会导致多态比想象的复杂一些。
, “重载”就是多台的体现, 多态就是父类的引用指向子类对象, “重载”就是多态,
]
我的理解有什么错误没有？哪里需要修正？, 1.同一类型的引用指向不同的对象时，
------行为的多态:重写的方法实现多态
2.同一个对象被造型为不同的类型时，有不同的功能。。。
-----对象的多态。, 理解的很好呀，有些时候概念理解透彻需要通过实际项目中的应用，比如我们为什么要知道多态，为什么这样子的概念就是多态，反而这些是我们实践的结果。举个例子，一个项目中用到了一个支付功能，这样就需要调用第三方接口，比如银行，支付宝，微信等
那么我们怎么办才能让这三家接口对于我们来说是同样的，这就需要好好的设计定义一个统一的接口，然后有三个类分别实现这个方法，对于调用层而言就只知道一个方法传什么参数就可以，其他的都不用管。
我举这个简单例子就是为了让你知道概念来自于实际应用。, (1)同一个对象，在不同时刻表现出来的不同状态。
举例：水(水,冰,水蒸气)
猫(猫,动物)
(2)前提：
A:有继承或者实现关系。
B:有方法的重写。
C:有父类(接口)的引用指向子类对象。
(3)多态中的成员使用特点：
Fu fz = new Zi();
多态时，所有表现形式都是父类的表现形式，
只有调用方法时，运行的是子类重写的方法
A:成员变量
编译看左边，运行看左边。
B:成员方法
编译看左边，运行看右边。
(4)多态的好处及弊端：
A:好处
提高了程序可维护下和可扩展性。
B:弊端
不能使用子类特有内容。
要想使用，要么向下转型，要么重新创建子类对象。, 从C语言的数据结构上来理解。
多态，无论如何，最终还是对一个函数的调用。这个函数是一个函数指针，它有存储空间。
这个存储空间的值，指向不同的函数，就会体现为调用不同的函数。
而这个存储空间的值，怎么确定呢？
一个对象上的函数，如果标记为虚函数，那么会在类对象的存储空间里分配一个函数指针。
创建类对象时，这个函数指针必然会有一个确定的值。
当子函数覆盖override这个函数时，子类上的同名函数的地址，会写到上述的函数指针上。---这时，在基类调用改函数时，都会调用子类定义的函数。
--这个是 子类上体现的多态。
至于参数不同的多态，这个在编译器内部就处理掉了。参数不同，函数就不同，编译器会根据代码，准确知道应该使用那个函数，这种多态在C++里才有意义，C++里面是通过替换函数名来实现的。
接口上的多态更普遍。一个类实现了一些接口，依照我的理解，应该是建立了一个：接口-函数地址表，这个表在C++里面是静态的，通过.h文件来定义，在Java,C#里面则不一定了，具体没有深入研究，这里的坑有点深。但接口函数+接口实现+接口虚函数，这些条件综合考虑，就会导致多态比想象的复杂一些。
, “重载”就是多台的体现, 多态就是父类的引用指向子类对象, “重载”就是多态,
该回复于2017-12-31 14:58:19被管理员删除
,
]
#1
[重写，与重载理解好了，理解多态不难,
我的理解有什么错误没有？哪里需要修正？, 1.同一类型的引用指向不同的对象时，
------行为的多态:重写的方法实现多态
2.同一个对象被造型为不同的类型时，有不同的功能。。。
-----对象的多态。, 理解的很好呀，有些时候概念理解透彻需要通过实际项目中的应用，比如我们为什么要知道多态，为什么这样子的概念就是多态，反而这些是我们实践的结果。举个例子，一个项目中用到了一个支付功能，这样就需要调用第三方接口，比如银行，支付宝，微信等
那么我们怎么办才能让这三家接口对于我们来说是同样的，这就需要好好的设计定义一个统一的接口，然后有三个类分别实现这个方法，对于调用层而言就只知道一个方法传什么参数就可以，其他的都不用管。
我举这个简单例子就是为了让你知道概念来自于实际应用。, (1)同一个对象，在不同时刻表现出来的不同状态。
举例：水(水,冰,水蒸气)
猫(猫,动物)
(2)前提：
A:有继承或者实现关系。
B:有方法的重写。
C:有父类(接口)的引用指向子类对象。
(3)多态中的成员使用特点：
Fu fz = new Zi();
多态时，所有表现形式都是父类的表现形式，
只有调用方法时，运行的是子类重写的方法
A:成员变量
编译看左边，运行看左边。
B:成员方法
编译看左边，运行看右边。
(4)多态的好处及弊端：
A:好处
提高了程序可维护下和可扩展性。
B:弊端
不能使用子类特有内容。
要想使用，要么向下转型，要么重新创建子类对象。, 从C语言的数据结构上来理解。
多态，无论如何，最终还是对一个函数的调用。这个函数是一个函数指针，它有存储空间。
这个存储空间的值，指向不同的函数，就会体现为调用不同的函数。
而这个存储空间的值，怎么确定呢？
一个对象上的函数，如果标记为虚函数，那么会在类对象的存储空间里分配一个函数指针。
创建类对象时，这个函数指针必然会有一个确定的值。
当子函数覆盖override这个函数时，子类上的同名函数的地址，会写到上述的函数指针上。---这时，在基类调用改函数时，都会调用子类定义的函数。
--这个是 子类上体现的多态。
至于参数不同的多态，这个在编译器内部就处理掉了。参数不同，函数就不同，编译器会根据代码，准确知道应该使用那个函数，这种多态在C++里才有意义，C++里面是通过替换函数名来实现的。
接口上的多态更普遍。一个类实现了一些接口，依照我的理解，应该是建立了一个：接口-函数地址表，这个表在C++里面是静态的，通过.h文件来定义，在Java,C#里面则不一定了，具体没有深入研究，这里的坑有点深。但接口函数+接口实现+接口虚函数，这些条件综合考虑，就会导致多态比想象的复杂一些。
, “重载”就是多台的体现, 多态就是父类的引用指向子类对象, “重载”就是多态,]
我的理解有什么错误没有？哪里需要修正？, 1.同一类型的引用指向不同的对象时，
------行为的多态:重写的方法实现多态
2.同一个对象被造型为不同的类型时，有不同的功能。。。
-----对象的多态。, 理解的很好呀，有些时候概念理解透彻需要通过实际项目中的应用，比如我们为什么要知道多态，为什么这样子的概念就是多态，反而这些是我们实践的结果。举个例子，一个项目中用到了一个支付功能，这样就需要调用第三方接口，比如银行，支付宝，微信等
那么我们怎么办才能让这三家接口对于我们来说是同样的，这就需要好好的设计定义一个统一的接口，然后有三个类分别实现这个方法，对于调用层而言就只知道一个方法传什么参数就可以，其他的都不用管。
我举这个简单例子就是为了让你知道概念来自于实际应用。, (1)同一个对象，在不同时刻表现出来的不同状态。
举例：水(水,冰,水蒸气)
猫(猫,动物)
(2)前提：
A:有继承或者实现关系。
B:有方法的重写。
C:有父类(接口)的引用指向子类对象。
(3)多态中的成员使用特点：
Fu fz = new Zi();
多态时，所有表现形式都是父类的表现形式，
只有调用方法时，运行的是子类重写的方法
A:成员变量
编译看左边，运行看左边。
B:成员方法
编译看左边，运行看右边。
(4)多态的好处及弊端：
A:好处
提高了程序可维护下和可扩展性。
B:弊端
不能使用子类特有内容。
要想使用，要么向下转型，要么重新创建子类对象。, 从C语言的数据结构上来理解。
多态，无论如何，最终还是对一个函数的调用。这个函数是一个函数指针，它有存储空间。
这个存储空间的值，指向不同的函数，就会体现为调用不同的函数。
而这个存储空间的值，怎么确定呢？
一个对象上的函数，如果标记为虚函数，那么会在类对象的存储空间里分配一个函数指针。
创建类对象时，这个函数指针必然会有一个确定的值。
当子函数覆盖override这个函数时，子类上的同名函数的地址，会写到上述的函数指针上。---这时，在基类调用改函数时，都会调用子类定义的函数。
--这个是 子类上体现的多态。
至于参数不同的多态，这个在编译器内部就处理掉了。参数不同，函数就不同，编译器会根据代码，准确知道应该使用那个函数，这种多态在C++里才有意义，C++里面是通过替换函数名来实现的。
接口上的多态更普遍。一个类实现了一些接口，依照我的理解，应该是建立了一个：接口-函数地址表，这个表在C++里面是静态的，通过.h文件来定义，在Java,C#里面则不一定了，具体没有深入研究，这里的坑有点深。但接口函数+接口实现+接口虚函数，这些条件综合考虑，就会导致多态比想象的复杂一些。
, “重载”就是多台的体现, 多态就是父类的引用指向子类对象, “重载”就是多态,
该回复于2017-12-31 14:58:19被管理员删除
,
]