多态

面向对象编程思想-抽象 抽象的介绍 我们在前面去定义一个结构体时候，实际上就是把一类事物的共有的 属性( 字段)和 行为( 方法)提取 出来，形成一个 物理模型(结构体)。这种研究问题的方法称为抽象 比如一个银行账户： package main import ( "fmt" ) //定义一个结构体Account type Account struct { AccountNo string Pwd string Balance float64 } //方法 //1. 存款 func (account *Account) Deposite(money float64, pwd string) { //看下输入的密码是否正确 if pwd != account.Pwd { fmt.Println("你输入的密码不正确") return } //看看存款金额是否正确 if money <= 0 { fmt.Println("你输入的金额不正确") return } account.Balance += money fmt.Println("存款成功~~") } //取款 func (account *Account) WithDraw(money float64, pwd string) { //看下输入的密码是否正确 if pwd != account.Pwd { fmt.Println

父类函数不加virtual关键词，子类继承后，当父类指针指向子类指针，同样的函数，会执行父类的函数。子类的函数实际是被隐藏了，如果用子类的指针指向自己的话，是能够执行的。 #include <iostream> /** * C++多态 虚函数 */ using namespace std; class Shape { public: Shape(); ~Shape(); double calcArea(); }; class Circle : public Shape { public: Circle(double r); ~Circle(); double calcArea(); protected: double m_dR; protected: string m_strName; }; class Rect : public Shape { public: Rect(double width, double height); ~Rect(); double calcArea(); protected: double m_dWidth; double m_dHeight; }; Rect::Rect(double width, double height) { m_dHeight = height; m_dWidth = width; cout << "Rect::Rect()

　　通过前面的学习我们知道，事与物都是对象，我们都能将其定义为一个类，python中将该类定义为object，我们所创建的类都是直接或间接继承与object，他们都有object类的属性和方法，面向对象有抽象、继承、封装、多态四个特性。 抽象 　　创建类要通过class关键字来创建，比如有一个人，我们要实现他的类，我们把它抽象为Person 　　class Person: 　　　　pass #如果没有想要封装的属性我们可以通过pass关键字来结束 封装 　　对象有自己的属性和方法，比如一个人，他有自己的姓名和年龄的属性，他能干什么这是他的方法，我们可以定义他的名字属性为name，年龄为age，他能跑步、说话的方法，我们可以定义跑步run（），speak（） 　　class Person: 　　　　name = 'Tom' 　　　　age = 18 　　　　def run(self): 　　　　　　print('我正在跑步') 　　　　def speak(self): 　　　　　　print('我正在说话') 　　p = Person() # p就是类的一个实例体现 　　print(p.name,p.age) #打印结果: Tom 18 　　p.run() #打印结果: 我正在跑步 调用run（）方法我们不用传入参数，self是对象的实例，直接用p.run()就能实现实例方法 　　p

面向对象有三大特性：封装，继承，多态 一、封装 封装是指一种将抽象性函式接口的实现细节部份包装、隐藏起来的方法。 用private关键字将该类的方法或属性进行封装，主要功能是让程序更容易理解与维护 1.1 this.xxx l this 特殊引用，引用当前对象的地址 l this.xxx 调用成员 l 当有重名局部变量，必须用this.xx调用成员变量 1.2 this(...) l 构造方法之间调用 l 目的是减少代码重复，方便维护修改 l 一般从参数少的方法，调用参数多的方法 l this(...) 必须是首行代码 二、继承 　　继承的主要作用是代码重用、复用，而私有成员构造方法不能继承： 　2.1 子类对象 　　由父类对象和子类对象绑定，整体作为一个对象 　　调用成员时，先找子类，再找父类 　2.2 父类的构造方法 创建子类对象时，先创建父类对象，也要先执行父类的构造方法 默认执行父类的无参构造 super() 或者可以手动调用父类有参构造 super(...) 　2.3 super super.xxxx() 重写时，调用父类同一个方法的代码 　2.4 super(...) 调用父类的构造方法 必须是首行代码 三、多态 多态作用是将所有的子类型对象一致的类型，都可以被当做一致的父类型来处理 　3.1 向上转型 　　通过向上转型将子类型对象，转型成父类型 　

示例代码如下：解释都写在注释里面 #include<iostream> #include<string> using namespace std; class Cpu { //定义cpu类 public: virtual void calculate() = 0; }; class VideoCard {//定义VideoCard类 public: virtual void display() = 0; }; class Memory {//定义Memory类 public: virtual void storage() = 0; }; class InterCpu:public Cpu{ //封装一个InterCpu类 public: void calculate() { cout << "Intercpu正在计算" << endl; } }; class InterVideoCard:public VideoCard { //封装一个InterCpu类 public: void display() { cout << "InterVideoCard正在显示" << endl; } }; class InterMemory:public Memory{ //封装一个InterMemory类 public: void storage() { cout <<

boolean equals （Object obj）（return this==obj）； p1.equals（p2）； 基本数据类型比较的是值 引用数据类型：默认比较的是两个对象的地址值；this是指调用方法的对象，p1调用的equals方法this就是p1； 重写equals 方法，比较两个对象的属性： 问题：隐含着多态（多态无法使用子类特有的内容（属性和方法）） 　　对于多态的弊端，可以使用向下转型，把obj类型转换为person； Objects类可以防止空指针异常 来源： https://www.cnblogs.com/Damocless/p/11871481.html

示例代码如下： #include<iostream> #include<string> using namespace std; class Animal { public: virtual void speak() = 0; }; class Dog :public Animal{ public: void speak() { cout << "小狗在说话" << endl; } }; class Cat :public Animal { public: void speak() { cout << "小猫在说话" << endl; } }; void aaa(Animal * animal) { animal->speak(); //因为是指针，所以我们调用的时候使用-> delete animal; //用完之后释放内存 } void test01() { Animal * a1 = new Cat; aaa(a1); } int main() { test01(); system("pause"); return 0; } 来源： https://www.cnblogs.com/zpchcbd/p/11871380.html

多态的基本概念： 多态是C++面向对象三大特性之一 多态分为两类 1、静态多态: 函数重载 和 运算符重载属于静态多态，复用函数名 ，那么这个我们之前都有用到过 2、动态多态: 派生类和虚函数实现运行时多态 静态多态和动态多态区别： 1、静态多态的函数地址早绑定 - 编译阶段确定函数地址 2、动态多态的函数地址晚绑定 - 运行阶段确定函数地址 示例代码： #include<iostream> #include<string> using namespace std; class Animal { public: virtual void speak() { // 进行virtual修饰成员函数，变成虚函数，那么编译器在编译的时候就不能确定函数调用了。 cout << "动物在说话" << endl; } }; class Dog :public Animal{ public: void speak() { cout << "小狗在说话" << endl; } }; class Cat :public Animal { public: void speak() { cout << "小猫在说话" << endl; } }; void aaa(Animal & animal) { animal.speak(); } void test01() { Cat c1; aaa(c1);

extends继承或者implements实现，是多态性的前提。 多态的格式和使用： 代码当中体现多态性，其实就是一句话，父类引用指向子类对象。 格式：父类名称 对象名=new 子类名称（）； 左侧父类的引用指向了右侧子类的对象，把子类当做父类来进行看待， 访问成员变量的两种方式：（只有方法才能覆盖重写，成员变量不能覆盖重写）。 1直接通过对象名称访问成员变量，看等号左边是谁，优先使用谁，没有则向上找； 2间接通过成员方法访问成员变量；看该方法属于谁，优先使用谁，没有则向上找； 子类没有覆盖重写就是父，子类如果覆盖重写，就是子类 或者：接口名称 对象名=new 实现类名称（）； 在多态的代码当中，成员方法的访问规则是： 看new的是谁，就优先用谁，没有则向上找； 注意;编译看左边，运行看右边；（多态的体现） 成员变量不在此列 成员变量:编译看左边，运行看左边 来源： https://www.cnblogs.com/Damocless/p/11867405.html

实现多态的三个条件 继承的存在。继承是多态的基础，没有继承就没有多态 子类重写父类的方法，JVM 会调用子类重写后的方法 父类引用变量指向子类对象 向上转型 ：将一个父类的引用指向一个子类对象，自动进行类型转换。 通过父类引用变量调用的方法是子类覆盖或继承父类的方法，而不是父类的方法。 通过父类引用变量无法调用子类特有的方法。 向下转型 ：将一个指向子类对象的引用赋给一个子类的引用，必须进行强制类型转换。 向下转型必须转换为父类引用指向的真实子类类型，不是任意的强制转换，否则会出现 ClassCastException 向下转型时可以结合使用 instanceof 运算符进行判断 Java 自学指南 Java 面试题汇总PC端浏览【点这里】 Java知识图谱 Java 面试题汇总小程序浏览，扫二维码 所有资源 资源汇总于公众号 来源： https://www.cnblogs.com/ConstXiong/p/11864266.html