多态

场景描述 在开发的场景中，常常会遇到打折的业务需求，每个用户对应的等级，他们的打折情况也是不一样的。例如普通会员打9折，青铜会员打8.5折，黄金会员打8折等等。在一般开发中最简单的就是判断用户的等级，然后对订单作对应的打折处理。 场景示例 写了一个简单的小示例，如下所示： //1 代表学生 2老师 3校长 int type = 1; if (1 == type) { System.out.println("学生笑嘻嘻的说话"); } else if (2 == type) { System.out.println("老师开心的说话"); } else { System.out.println("校长严肃的说话"); } 上面的代码，是我们经常的做法，代码少的时候，看起来非常清晰，但是代码多起来或者有了更多的判断条件，那上面的代码会更加的混乱，如果每次有修改，都要改动这部分代码。 解决方法 可以把上面的代码改成多态方式，创建三个类，学生Student,老师Teacher,校长HeadMater，父类为Person，这三个类都实现父类的方法say，如下所示: Person.class package me.xueyao.service; /** * @author Simon.Xue * @date 2019-12-01 14:31 **/ public interface

向上转型:子类型向父类型转换 <父类型> <引用变量名>=new <子类型>(); 父类的引用指向子类对象，父类的引用调用方法：（低类型到高类型，顺其自然） 1.必须在子类里面进行重写 2.子类中特有的方法不能进行调用 3.必须发生了继承 向下转型:父类型转化为子类型 <子类型> <引用变量名>=(<子类型>)<父类型的引用变量> 子类的引用指向父类的引用变量（由高类型到低类型，属于强转），可以调用子类独有的方法。 来源： https://www.cnblogs.com/lei1121/p/11714239.html

多态 多态与多态性 多态指的是同一种事物的多种状态：水这种事物有多种不同的状态：冰，水蒸气 多态性的概念指出了对象如何通过他们共同的属性和动作来操作及访问,而不需考虑他们具体的类。 冰，水蒸气，都继承于水，它们都有一个同名的方法就是变成云，但是冰.变云(),与水蒸气.变云()是截然不同的过程，虽然调用的方法都一样 就列如动物有多种形态：猫，狗，猪 import abc class Animal(metaclass=abc.ABCMeta): #同一类事物:动物 @abc.abstractmethod def talk(self): pass class cat(Animal): #动物的形态之一:猫 def talk(self): print('say hello') class Dog(Animal): #动物的形态之二:狗 def talk(self): print('say wangwang') class Pig(Animal): #动物的形态之三:猪 def talk(self): print('say aoao') 文件有多种形态：文本文件，可执行文件 import abc class File(metaclass=abc.ABCMeta): #同一类事物:文件 @abc.abstractmethod def click(self): pass class Text

原文链接 http://www.limerence2017.com/2019/10/11/golang15/ interface 意义？ golang 为什么要创造interface这种机制呢？我个人认为最主要的就是做约束，定义一种规范，大家可以按照同一种规范实现各自的功能，从而实现多态。 同时当interface做函数形参，可以很好地限制传入参数，并且根据不同的实参调用达到多态的效果。多态的意思就是多种多样的功能，比如我们定义了一 个接口 1234 type IOInter interface{ write()int read()int} 定义了一个IOInter的接口，只要别人实现了write和read方法，都可以转化为这个接口。至于具体怎么读，读什么，网络IO还是文件IO取决于具体的实现， 这就形成了多样化的功能，从而实现多态。同时IOInter做函数的形参， 123 func WriteFunc(io IOInter){ io.Write()} 还达到了安全限制的功能。比如没有实现读写功能的类实例无法传给WriteFunc,WriteFunc内部调用io的Write函数会根据实参具体的实现完成特定的读写。 我们通过一个小例子实战下接口做形参的意义。golang中sort包提供了几个排序api，我们先实现一个int类型slice排序功能。 123 arrayint := [

静态绑定与动态绑定 静态绑定/前期绑定：简单的可以理解为程序编译期的绑定。java当中的方法只有final，static，private和构造方法是前期绑定 private方法不能被继承，只能通过这个类自身的对象来调用，因此private方法和类绑定在了一起。 final方法可以被继承，但不能被重写（覆盖）， 将方法声明为final类型，一是为了防止方法被覆盖，二是为了有效地关闭java中的动态绑定。 static方法可以被子类继承，但是不能被子类重写（覆盖），可以被子类隐藏。 动态绑定/后期绑定：在运行时根据具体对象的类型进行绑定。动态绑定的过程：虚拟机提取对象的实际类型的方法表 -> 虚拟机搜索方法签名 -> 调用方法。 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475 import java.util.ArrayList;import java.util.List;public class { public static void main(String[] args) { List<Animal> list = new ArrayList<>(

一.简介 二.使用继承 三.继承的调用顺序 #pragma once #include <iostream> using namespace std; class F{ public: F(){ k5 = 10; cout << "F:F()" << endl; } ~F(){ cout << "F:~F()" << endl; } //virtual ~F(){} void FuncA(){ cout << "F:FuncA()" << endl; } virtual void FuncB() { cout << "F::FuncB()" << endl; } int k5; protected: int k4; }; class Z : public F{ public: Z(){ k5 = 5; cout << "Z:Z()" << endl; } ~Z(){ cout << "Z:~Z()" << endl; } void FuncA(){ cout << "Z::FuncA()" << endl; } void FuncB() { cout << "Z::FuncB()" << endl; } int k5; protected: int k4; }; #include "Jicheng.h" int main() { F* a = new F(); //F() cout

多态的弊端 ： 父类不能使用子类的功能 虽然我们可以创建子类对象调用方法，但是不合理，且会占用大量内存；（new新对象占用额外内存）； 下面我们解决了这个问题！！ 把父类的引用强制转换为子类的引用，这种叫做向下转移； class Fu { public void show ( ) { System . out . println ( "shouw fu" ) ; } } class Zi extends Fu { public void show ( ) { System . out . println ( "show zi" ) ; } public void method ( ) { System . out . println ( "method zi" ) ; } } public class DuoTai { public static void main ( String [ ] args ) { Fu f = new Zi ( ) ; f . show ( ) ; //f.method(); 编译看左边，只有show ,没有method，所以编译会报错 // Fu类对象f不能调用method()；因为他没有 这就是多态的弊端，父类不能使用子类的功能； /* Zi z=new Zi(); z.show(); z.method(); 这样虽然可以但是不合理

#多态：由不同的类实例化得到的对象，调用一个方法，执行的逻辑不同#多态的概念：指出了对象如何通过他们共同的属性和动作来操作及访问，而不需要考虑他们具体的类#多态是反映运行时候的一种情况，python本身就是一种多态#python本身就是一种多态代码例子如下：#我们经常看到的执行情况# li=[1,2,4,9]# print(len(li))# str="asdlasjdlas"# print(len(str))## #python时间运行情况# li=[1,2,4,9]# print(li.__len__())# str="asdlasjdlas"# print(str.__len__())#li 和 str虽然不是相同的对象，但是可以调用方法__len__方法#多态的例子class H2O: def __init__(self,name,shuizhuantai): self.name=name, self.shuizhuantai=shuizhuantai def turn_ice(self): if self.shuizhuantai<0: print("[%s]温度太低结冰了"%self.name) elif self.shuizhuantai>0 and self.shuizhuantai<100: print("[%s]液化成水"%self.name) elif

多态？盘 事物在运行过程中存在不同的状态，多态存在三前提 　　1、要有继承关系 　　2、子类要重写父类的方法 　　3、父类引用指向子类 　　 　　 　　 　　 　　多态成员访问的特定：(编译时多态、运行时多态) 　　成员变量 　　编译看左边(父类)，运行时看左边(父类) 　　成员方法 　　编译看左边，运行看右边(子类)。动态绑定 　　静态方法 　　编译看左边(父类)，运行时看左边(父类)---静态和类相关，算不上重写，所以访问还是左边的 　　只有非静态的成员方法，编译看左边，运行看右边，即多态不能使用子类特定的属性和方法(多态中的向上转型)。编译是报错 　　 　　怎么办呢？即强转(多态中的向下转型)---转型之后使用的是子类的属性和方法 　　 　　　　 　　使用多态好处的例子 　　 　 　 　　打印结果： 　　　 学生类 　　　老师类 　　　好处：同一个方法，传入不同的对象，执行不同对象的相应方法，便于集中管理 　　　就比如你们老板安排任务，他肯定说猪仔们今晚加班，而不是说张三、李四、王五。。。。加班，对吧小老弟。 　　 来源： https://www.cnblogs.com/south-pigeon/p/11688566.html

　　　　主要介绍的内容为：泛型编程和面向对象编程 (1) 泛型编程和面向对象编程虽然分属于不同思维，但他们正是c++的技术主线，所以也将会记录template(模板) (2) 深入探索面向对象之继承关系所形成的对象模型，包括隐含与底层的this指针,vptr(虚指针),vtbl(虚表), virtual nechanism(虚机制)以及虚函数(virtual functions)造成的polymorphism(多态)效果。 来源： https://www.cnblogs.com/huahuati/p/11687768.html