多态

前言 介绍 类型 编码和底层数据结构 五种常见的对象类型 类型检查与命令多态 内存回收 对象共享 对象淘汰：空转时长 总结 参考文章 联系我 前言 其实关于本文，我犹豫再三。 对象系统值得写一篇文章吗？从技术上来讲，当然是值。但是对于我们大部分人来说，它都是隐身的。 写的话，顺序放在哪里？在 Redis 系列（九）底层数据结构之五种基础数据类型的实现 中其实就提到了，那么应该在此之前先介绍它吗？ 结论：想那么多屁事，写就完事了。 介绍 正如上一篇文章提到的，Redis 不是生硬的使用前面介绍过的数据结构，来实现了字符串，列表，字典等等数据结构，而是精心打造了一个对象系统。 对于 Redis 来说，所有的所谓的数据类型，本质上都是一个对象，而且同一个类型的对象，底层实现编码不一样。 Redis 对象的定义为： // 类型 typedef type : 4 ; // 编码 unsigned encoding : 4 ; // 指向底层数据结构的指针 void * ptr ; . . . 类型 对象的 type 属性，记录了对象的类型，这个类型就是我们所熟知的 Reids 的数据类型了，比如字符串，列表，集合，有序集合，散列等。 对于 Redis 数据库中的键值对来讲，键值永远是一个字符串对象，值可以是很多种。 编码和底层数据结构 对象的 ptr 指针，指向对象的底层数据结构

多态性 首先理解一下什么叫多态。同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果，这就是多态性。 多态性通过派生类覆写基类中的虚函数型方法来实现。 多态性分为两种，一种是编译时的多态性，一种是运行时的多态性。 编译时的多态性：编译时的多态性是通过重载来实现的。对于非虚的成员来说，系统在编译时，根据传递的参数、返回的类型等信息决定实现何种操作。 运行时的多态性：运行时的多态性就是指直到系统运行时，才根据实际情况决定实现何种操作。C#中运行时的多态性是通过覆写虚成员实现。 下面我们来分别说明一下多态中涉及到的四个概念：重载，覆写，虚方法和抽象方法。 重载和覆写的区别： 重载 类中定义的方法的不同版本 public int Calculate(int x, int y) public double Calculate(double x, double y) 特点（两必须一可以） 方法名必须相同 参数列表必须不相同 返回值类型可以不相同 覆写 子类中为满足自己的需要来重复定义某个方法的不同实现。 通过使用override关键字来实现覆写。 只有虚方法和抽象方法才能被覆写。 要求（三相同） 相同的方法名称 相同的参数列表 相同的返回值类型 例： public class Test { public int Calculate(int x, int y) { return x +

重载，继承，重写和多态的区别： 继承是子类获得父类的成员，重写是继承后重新实现父类的方法。 重载是在一个类里一系列参数不同名字相同的方法。 多态则是为了避免在父类里大量重载引起代码臃肿且难于维护。 网上看到一个有趣的说法是：继承是子类使用父类的方法，而多态则是父类使用子类的方法。 下面的例子包含了这四种实现： class Triangle extends Shape { public int getSides() { //重写 return 3; } } class Rectangle extends Shape { public int getSides(int i) { //重载 return i; } } public class Shape { public boolean isSharp(){ return true; } public int getSides(){ return 0 ; } public int getSides(Triangle tri){ return 3 ; } public int getSides(Rectangle rec){ return 4 ; } public static void main(String[] args) { Triangle tri = new Triangle(); //继承 System.out.println

多态（狭义上的）：同一个方法对不同的对象调用行为不同的现象。 重写：同一方法在不同类中的重新实现。 重载：不同的方法。 多态包括 重写 重载 来源： https://www.cnblogs.com/clemente/p/10768269.html

如果子类重写的父类的方法的访问权限低于其在父类中的访问权限，会影响多态。 在父类中是public的方法，如果子类中将其降低访问权限为private， 那么父类在实现多态时如果调用子类的这个重写方法，但是这个方法已经是private，没有办法调用，所以就无法实现多态了。 public class Test { public static void main ( String [ ] args ) { Father father = new Son ( ) ; father . method ( ) ; //出错，降低了访问权限，无法访问私有属性, } } //声明一个父类 class Father { public void method ( ) { System . out . println ( "我是父类" ) ; } } //声明一个子类，并重写父类method，并降低其访问权限 class Son extends Father { @Override private void method ( ) { //其实，在eclipse中，当重写时，将访问权限降低后，编译也无法通过。 System . out . println ( "我是子类" ) ; } } 另外，对于父类中私有的方法和属性，子类是可以完全继承的，但是子类不可以直接访问私有的属性和方法

继承 继承的概述 继承概述 多个类中存在相同的属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需在定义这些属性和行为，只要继承那个类即可 单独的这个类称为父类，基类或者叫超类，多个类可以称为子类或者派生类 有了继承以后，我们定义一个类的时候，可以在一个已经存在的类的基础上，还可以定义自己的新成员 实现继承的方式 通过extends关键字可以实现类与类的继承 格式： public class 子类名 extends 父类名{} 标准人类 继承的格式： public class 子类名 extends 父类名 {} 继承的好处： A:提高了代码的复用性 B:提高了代码的维护性 C:让类与类之间产生了关系，是多态的前提 继承的弊端： 让类与类之间产生了关系，也就让类的耦合性增强了。 开发原则：高内聚，低耦合。 内聚：就是自己完成某件事情的能力 耦合：类与类的关系 public class Person { private String name ; private int age ; public Person ( ) { } public String getName ( ) { return name ; } public void setName ( String name ) { this . name = name ; } public int getAge ( ) {

1.多态概述 多态 ：在继承层次结构中，父类中定义的行为被子类重写后表现出不同的效果，它使得同一个行为在父类及其子类中具有不同的语义，可以简单理解为：事物存在的多种形态。 比如说：动物（父类）有move（）方法，至于怎么移动，就要看动物的子类了，猫可以跑，鸟可以飞，鱼可以游，他们都继承自动物这个类，并且重写了父类的move（）方法。 前提 有继承关系 有方法重写 有父类引用指向子类对象 Father f = new Son（）； 注：如果把子类对象赋给父类引用（将子类对象当作父类对象看待），那么就只能调用父类中已有的方法。 好处 提高了代码的维护性（继承保证）和扩展性（由多态保证） 消除了类之间的耦合性（类之间的耦合是由于继承引起的） 可以当作形式参数，接受任意子类对象。 弊端 不能使用子类特有的属性和行为。 静态绑定和动态绑定 调用对象方法的执行过程： 编译器获取所有可能被调用的候选方法 编译器根据实参类型从候选方法中匹配出应该调用的方法 静态绑定：编译器可以准确的知道，应该调用哪个方法。 动态绑定。 多态中成员访问特点 成员变量：编译时看左边（父类），运行时也看左边（父类）。 成员方法：编译时看父类，运行时看子类（实际进栈方法是子类方法）。 静态方法：编译时看父类，运行时看父类（静态和类相关，算不上重写）。 补充： 当作参数时用多态最好，因为可扩展性强

文章目录 静态联编和动态联编 多态原理解析 静态联编和动态联编 多态是面向对象程序设计语言中数据抽象和继承之外的第三个基本特征。 多态性(polymorphism)提供接口与具体实现之间的另一层隔离，从而将”what”和”how”分离开来。多态性改善了代码的可读性和组织性，同时也使创建的程序具有可扩展性，项目不仅在最初创建时期可以扩展，而且当项目在需要有新的功能时也能扩展。 c++支持编译时多态(静态多态)和运行时多态(动态多态)，运算符重载和函数重载就是编译时多态，而派生类和虚函数实现运行时多态。 静态多态和动态多态的区别就是函数地址是早绑定(静态联编)还是晚绑定(动态联编)。如果函数的调用，在编译阶段就可以确定函数的调用地址，并产生代码，就是静态多态(编译时多态)，就是说地址是早绑定的。而如果函数的调用地址不能编译不能在编译期间确定，而需要在运行时才能决定，这这就属于晚绑定(动态多态,运行时多态)。 静态联编 地址早绑定 编译阶段绑定好地址 动态联编 地址晚绑定 运行阶段绑定好地址 # define _CRT_SECURE_NO_WARNINGS # include <iostream> using namespace std ; class Animal { public : virtual void speak ( ) { cout << "动物在说话" << endl ;

java day09 多态 多态概述 多态前提 * 要有继承关系 * 要有方法重写 * 要有父类引用指向子类对象 class a { public static void main ( String [ ] args ) { cat c = new cat ( ) ; c . eat ( ) ; animal a = new cat ( ) ; //父类引用指向子类对象 a . eat ( ) ; } } class animal { public void eat ( ) { System . out . println ( "eat" ) ; } } class cat extends animal { //继承 public void eat ( ) { //重写 System . out . println ( "cat eat" ) ; } } 成员变量的引用 class a { public static void main ( String [ ] args ) { father f = new son ( ) ; System . out . println ( f . num ) ; son s = new son ( ) ; System . out . println ( s . num ) ; } } class father { int num = 10

成员变量静态方法看左边，非静态方法编译看左边，运行看右边。 左边Father f其实是定义了一个Father类的对象，而右边new Son()可以只理解为是一个重写了Father类方法的对象。 因此，f的成员变量，静态方法都是Father类的，而只有被重写的方法才是调用Son类的。 所以编译看左边指的是如果调用Son类的特有方法的话会编译错误，因为这个 被重写的Father类 里并没有这个Son类的特有方法。 class Father{ int a=1; static int b=2; void say(){ System.out.println("I am father"); } void ffun(){ System.out.println("father's function"); } static void fun(){ System.out.println("static father"); } } class Son extends Father{ int a=3; static int b=4; void say(){ System.out.println("I am son"); } void sfun(){ System.out.println("son's function"); } static void fun(){ System.out.println(