多态

最新推荐文章于 2021-06-19 12:50:27 发布
最新推荐文章于 2021-06-19 12:50:27 发布
阅读量91 收藏
点赞数
原文链接：http://www.cnblogs.com/mjhelloworld/p/4788964.html
版权

转载于：http://www.cnblogs.com/dx-230/p/4773848.html

什么是多态

　　什么是多态:

　　　　多态就是某一类事物的多种形态　　　　

　　　　　　猫: 猫-->动物

　　　　　　狗: 狗-->动物

　　　　　　男人 : 男人 -->人 -->动物

　　　　　　女人 : 女人 -->人 -->动物

　　　　多态表示不同的对象可以执行相同的动作, 但是通过他们自己的实现代码来执行

　　程序中的多态:父类指针指向子类对象

多态的条件

　　有继承关系

　　子类重写父类方法

　　父类指针指向子类对象
          狗 *g = [狗 new];
          动物 *a = [狗 new];
          猫 *c = [猫 new];
          动物 *a = [猫 new];

　　表现：当父类指针指向不同的对象的时候，通过父类指针调用被重写的方法的时候，会执行该指针所指向的那个对象的方法

多态的优点

　　多态的主要好处就是简化了编程接口。它允许在类和类之间重用一些习惯性的命名,而不用为每一个新的方法命名一个新名字。这样,编程接口就是一些抽象的行为的集合,从而和实现接口的类的区分开来。

　　多态也使得代码可以分散在不同的对象中而不用试图在一个方法中考虑到所有可能的对象。 这样使得您的代码扩展性和复用性更好一些。当一个新的情景出现时,您无须对现有的代码进行 改动,而只需要增加一个新的类和新的同名方法。

多态的原理

　　动态绑定:

　　　　动态类型能使程序直到执行时才确定对象的真实类型

　　　　动态类型绑定能使程序直到执行时才确定要对那个对象调用的方法

　　OC可以在运行时加入新的数据类型和新的程序模块:动态类型识别,动态绑定,动态加载

　　id类型:通用对象指针类型,弱类型,编译时不进行具体类型检查

　　补充:

　　　　动态数据类型:     在编译的时候编译器并不知道变量的真实类型, 只有在运行的时候才知道它的真实类型  并且如果通过动态数据类型定义变量, 如果访问了不属于动态数据类型的属性和方法, 编译器不会报错

　　　　静态数据类型:     默认情况下所有的数据类型都是静态数据类型, 在编译时就知道变量的类型, 知道变量中有哪些属性和方法 , 在编译的时候就可以访问这些属性和方法, 并且如果是通过静态数据类型定义变量, 如果访问不了属于静态数据类型的属性和方法, 那么编译器就会报错

　　　　里氏替换原则:    子类对象能够替换其父类对象被使用。就是说“子类是父类”，比如，人是动物，但动物不一定是人，有一个Animal类和一个继承自Animal类的Person类,  这时, Animal类型的变量可以指向Person类的实例, 但是Person类类型的变量不能指向Animal类的实例！

　　　　开放封闭原则：软件实体(类  模块  函数等等) 应该可以扩展,但是不可修改. 这个原则其实是有两个特征:

　　　　　　一个是说"对于扩展是开放的(Open for extension) " : 意味着有新的需求时，可以对已有的软件实体进行扩展，以满足新的需求     

　　　　　　一个是说"对于更改是封闭的(Closed for modification)"  : 意味着软件实体一旦设计完成，就可以独立完成其工作，而不要对其进行任何修改。

多态的实现

　　人喂宠物吃东西的例子:

　　　　人(Person)   行为: 喂宠物吃东西(feedPet)   

　　　　宠物(Pets)   行为: 吃东西(eat)

　　　　猫(Cat)         行为: 吃东西(eat)

　　　　狗(Dog)        行为: 吃东西(eat)

　　　　(猫类和狗类 继承自宠物类)

　　示例代码:

　　　　宠物类的声明实现:

复制代码 
　　　　　　#import <Foundation/Foundation.h>
　　　　　　@interface Pets : NSObject
　　　　　　// 吃东西
　　　　　　- (void) eat; 　　　　　　@end 　　　　　　#import "Pets.h" 　　　　　　@implementation Pets 　　　　　　// 吃东西 　　　　　　- (void)eat{ 　　　　　　 NSLog(@"宠物吃东西"); 　　　　　　} 　　　　　　@end
复制代码

　　　　猫类的声明实现:

复制代码 
            #import "Pets.h"
            @interface Cat : Pets // 猫类特有的方法 抓老鼠 - (void) catchMouse; @end #import "Cat.h" @implementation Cat // 重写父类吃东西方法 - (void)eat{ NSLog(@"人喂宠物猫吃东西"); } 　　　　　　 // 实现猫类特有的方法 抓老鼠 　　　　　 　 - (void)catchMouse{ 　　　　　　　　NSLog(@"老猫抓老鼠"); 　　　　　　 } 　　　　　　@end
复制代码

　　　　狗类的声明实现:

复制代码 
　　　　　　#import "Pets.h"
　　　　　　@interface Dog : Pets 　　　　　　@end 　　　　　　#import "Dog.h" 　　　　　　@implementation Dog 　　　　　　// 重写父类吃东西方法 　　　　　　- (void)eat{ 　　　　　　 NSLog(@"人喂宠物狗吃东西"); 　　　　　　} 　　　　　　@end
复制代码

　　　　人类的声明实现:　　　　　　

复制代码 
　　　　　　#import "Pets.h"
　　　　　　@interface Person : NSObject 　　　　　　// 喂宠物吃东西 　　　　　　+ (void) feedPet:(Pets *) pet; 　　　　　　@end 　　　　　　#import "Person.h" 　　　　　　@implementation Person 　　　　　　// 喂宠物吃东西 　　　　　　+ (void)feedPet:(Pets *)pet{ 　　　　　　 [pet eat]; 　　　　　　} 　　　　　　@end
复制代码

　　　　Main.m :

复制代码 
　　　　　　#import <Foundation/Foundation.h>
　　　　　　#import "Person.h"
　　　　　　#import "Pets.h" 　　　　　　#import "Dog.h" 　　　　　　#import "Cat.h" 　　　　　　int main(int argc, const char * argv[]) { 　　　　　　 // 多态的体现 　　　　　　 Pets * pet = [Pets new]; 　　　　　　 [Person feedPet:pet]; 　　　　　　 pet = [Dog new]; 　　　　　　 [Person feedPet:pet]; 　　　　　　 　　　　　　 pet = [Cat new]; 　　　　　　 [Person feedPet:pet]; 　　　　　　 return 0; 　　　　　　}
复制代码

　　　　输出结果:　　　　　　

 　　　　　　/*
            2015-08-31 18:10:06.659 多态示例[833:53348] 宠物吃东西
 　　　　　　 2015-08-31 18:10:06.660 多态示例[833:53348] 人喂宠物狗吃东西
 　　　　　　 2015-08-31 18:10:06.660 多态示例[833:53348] 人喂宠物猫吃东西 
*/

　　》在上面代码中我们将Dog 和 Cat的实例赋值给了Pets类型的变量 pet  , 即父类类型的指针指向了子类的对象, 这便是里氏替换原则的体现

　　》我们给Person类定义了一个类方法 :   + (void) feedPet:(Pets) pet;  这个方法是接收一个Pets类型的对象作为参数, 然后再方法体里通过传进来的对象调用吃的方法(eat), 我们给feedPet方法传递的参数都是Pets类型的变量 pet,  但是通过输出结果可以知道, 实际上是分别调用了宠物   狗 和 猫  的吃的方法  也就是说:当父类指针指向不同的对象的时候，通过父类指针调用被重写的方法，会执行该指针所指向的那个对象的方法, 这就是多态

多态注意点

　　  父类指针指向子类对象, 如果需要调用子类特有的方法, 必须先强制类型转换为子类才能调用   

    Pets * pet = [Cat new];
    // 错误信息: No visible @interface for 'Pets' declares the selector 'catchMouse'
    [pet catchMouse];
    // 类型转换后在调用方法 [(Cat *)pet catchMouse];

 

封装继承多态练习(示例源于 大话设计模式  程杰著)

实现一个计算机控制台程序   要求输入两个数和操作符   输出结果

　　1.0版:

复制代码 
#import <Foundation/Foundation.h>

int main(int argc, const char * argv[]) { double a =1, b = 10, c = 0; char d = '+'; if(d == '+'){ c = a + b; } if( d == '-'){ c = a - b; } if( d == '*'){ c = a * b; } if( d == '/'){ c = a / b; } NSLog(@" 运算结果:%.2lf", c); return 0; }
复制代码

　　结论:

　　　　"代码无错就是优" 能获得想要的结果  挺好的嘛

　　问题:

    　　 1: 变量命名不规范   a b c d  没啥意义  看着名字也不知道是用来干嘛的

    　　 2: 注释都没有  程序只有自己暂时能看懂

    　　 3: 每个if都要判断一遍

   　　  4: 做除法时如果除以 0 会怎么样

　　2.0版:

复制代码 
#import <Foundation/Foundation.h>
 
int main(int argc, const char * argv[]) { // 用于计算的两个数字和运算符应有用户输入 此处写死在程序中 double num1 = 10, num2 = 20, result = 0; char operate = '+'; // 根据输入的运算符选择运算方式并获得运算结果 switch (operate) { case '+': result = num1 + num2; break; case '-': result = num1 - num2; break; case '*': result = num1 * num2; break; case '/': if (num2 != 0) { result = num1 / num2; } else{ NSLog(@"除数不能为 0"); // 是除数还是被除数啊 忘了  } break; } NSLog(@"运算结果是: %.2lf", result); return 0; }
复制代码

　　结论: 

　　　　好了  变量名像点样了  也不会做没必要的判断了  还能得到想要的结果  这总没问题了吧

　　书摘: 

　　　　"碰到问题就直觉的用计算机能够理解的逻辑来描述和表达待解决的问题和具体的求解过程,这本身没有错, 但这样的思维却使得我们的程序只为满足实现当前的需求, 程序不容易维护, 不容易扩展, 更不容易复用,从而达不到高质量代码的需求"

　　问题:  

　　　　现在的计算器只是控制台的输出  如果要做个桌面程序  或者网站上的计算器  或者是手机应用怎么办??  把代码拷贝过去?? 怎么让代码复用呢

　　3.0版:

　　Operation类声明文件:

复制代码 
// 添加一个Operation运算类
#import <Foundation/Foundation.h>

@interface Operation : NSObject
// 传入两个数字 和 一个操作符 获得运算结果 + (double) getResultOfNum1:(double) num1 andNum2: (double) num2 withOperate:(char) operate; @end
复制代码

　　Operation类实现文件:

复制代码 
#import "Operation.h"
 
@implementation Operation // 根据传入的两个数字和运算符获得运算结果 + (double)getResultOfNum1:(double)num1 andNum2:(double)num2 withOperate:(char)operate{ // 用于存储结果 double result = 0; // 选择运算方式并获得结果 switch (operate) { case '+': result = num1 + num2; break; case '-': result = num1 - num2; break; case '*': result = num1 * num2; break; case '/': if (num2 != 0) { result = num1 / num2; } else{ NSLog(@"除数不能为 0"); } break; } // 返回运算结果 return result; } @end
复制代码

　　Main.m:

复制代码 
#import <Foundation/Foundation.h>
#import "Operation.h" 

int main(int argc, const char * argv[]) { // 两个参与运算的数字 res用于存储运算结果 double num1 = 10, num2 = 20, res = 0; // 运算符 char ope = '*'; // 调用运算类的运算方法获得结果 res = [Operation getResultOfNum1:num1 andNum2:num2 withOperate:ope]; // 打印输出 NSLog(@"运算结果是:%.2lf", res); return 0; }
复制代码

　　结论:

　　　　现在通过封装把计算和显示分开了  也就是实现了业务逻辑和界面逻辑的分离  这里主函数中的代码也精简了一些 不用去管方法里面到底是怎么得到结果的  运算类的代码也不用去动便可复用 

　　问题:

　　　　但是 怎么让代码可以灵活的扩展呢? 比如要加一个求余 开方等运算进去,  我们现在需要改动的是在运算类的switch中添加分支就行了, 但是这样真的好吗? 只是加一个运算符却需要其他已经有的运算符都来参与编译 

　　书上举例:

　　　　"现在公司要你维护薪资管理系统, 原本只有技术人员(月薪) 销售(底薪+提成) 经理(年薪+股份)这三种运算算法, 现在需要加一个兼职员工(日薪)的算法, 按照现在这种做法, 公司必须把包含原有三种算法的类交给你来修改, 如果一不小心将兼职员工工资算法加进去的同时,顺手把技术人员的月薪提高那么一丢丢, 是不是很爽呢, 总有人不爽的" 

　　优化:

　　　　将加减乘除等运算做分离, 修改其中一个也不影响其他, 增加运算算法也不影响已有的算法, 这就是对扩展开放, 对修改封闭--开放-封闭原则

　　4.0版:

　　Operation类的声明实现:　　　　

复制代码 
#import <Foundation/Foundation.h>
 @interface Operation : NSObject
{
    @public
    double _number1; double _number2; } - (void) setNumber1: (double) number1; - (void) setNumber2: (double) number2; // 获取运算结果 - (double) getResult; @end #import "Operation.h" @implementation Operation - (void)setNumber1:(double)number1{ _number1 = number1; } - (void)setNumber2:(double)number2{ _number2 = number2; } // 获取运算结果 - (double)getResult{ double result = 0; return result; } @end
复制代码

　　加法类的声明实现:

复制代码 
#import "Operation.h"
// 加法运算类 @interface OperationAdd : Operation @end #import "OperationAdd.h" @implementation OperationAdd // 获得两数相加结果 - (double)getResult{ double result = 0; result = _number1 + _number2; return result; } @end
复制代码

　　减法类的声明实现:

复制代码 
#import "Operation.h"
// 减法运算类 @interface OperationSub : Operation @end #import "OperationSub.h" @implementation OperationSub // 获得两数相减的结果 - (double)getResult{ double result; result = _number1 - _number2; return result; } @end
复制代码

　　乘法类的声明实现:

复制代码 
#import "Operation.h"
// 乘法运算类 @interface OperationMul : Operation @end #import "OperationMul.h" @implementation OperationMul // 获得两数相乘的结果 - (double)getResult{ double result = 0; result = _number1 * _number2; return result; } @end
复制代码

　　除法类的声明实现:

复制代码 
#import "Operation.h"
// 除法运算类 @interface OperationDiv : Operation @end #import "OperationDiv.h" @implementation OperationDiv // 获得两数相除的结果 - (double)getResult{ double result = 0; if (_number2 != 0) { result = _number1 / _number2; } else{ NSLog(@"除数不能为 0"); } return result; } @end
复制代码

　　工厂类的声明实现:

复制代码 
#import "OperationAdd.h"
#import "OperationSub.h" #import "OperationMul.h" #import "OperationDiv.h" // 专门用于获得运算类实例 @interface GetOperation : NSObject + (Operation *) createOperationWithOperate: (char) operate; @end #import "GetOperation.h" @implementation GetOperation // 获得运算类实例 + (Operation *)createOperationWithOperate:(char)operate{ // 多态的应用 父类指针指向子类实例对象 Operation * ope = nil; // 根据传入的操作符获得相应的实例对象 switch (operate) { case '+': ope = [OperationAdd new]; break; case '-': ope = [OperationSub new]; break; case '*': ope = [OperationMul new]; break; case '/': ope = [OperationDiv new]; break; } return ope; } @end
复制代码

　　Main.m:

复制代码 
#import <Foundation/Foundation.h>
#import "GetOperation.h" 

int main(int argc, const char * argv[]) { double num1 = 10, num2 = 20, res = 0; char operate = '*'; Operation * ope = [GetOperation createOperationWithOperate:operate]; ope.number1 = num1; ope.number2 = num2; res = [ope getResult]; NSLog(@"运算结果是: %.2lf", res); return 0; }
复制代码

　　　现在如果要修改其中一种运算 对其他的运算都不会有影响了  如果想要添加一种新运算  也只需要添加一个新运算类  然后在工厂方法中修改下switch分支就行了  不需要再提供原有的运算类  所以对其他已经存在的运算类都不会有影响   这样便实现了开放-封闭原则

转载于:https://www.cnblogs.com/mjhelloworld/p/4788964.html

weixin_34281537
关注
多态java喂食宠物_JAVA代码主人喂宠物吃东西狗只吃骨头猫只吃鱼求代码用多态...
weixin_33582311的博客
02-13 1496
展开全部/*animal是个抽象方法，Cat和Dogextends这个就是用的多e68a843231313335323631343130323136353331333339663966态*/packageTest;publicclassTest{publicstaticvoidmain(String[]args){Feederfeeder=newFeeder();fee...
OC基础--多态 及 三特性小练习
aishen2615的博客
08-31 126
什么是多态 　　什么是多态: 　　　　多态就是某一类事物的多种形态　　　　 　　　　　　猫: 猫-->动物 　　　　　　狗: 狗-->动物 　　　　　　男人 : 男人 -->人 -->动物 　　　　　　女人 : 女人 -->人 -->动物 　　　　多态表示不同的对象可以执行相同的动作, 但是通过他们自己的实现代码来执行 　　程序中的多态...
重载方法吃
weixin_30417487的博客
04-09 80
public class Person { String name; int age; void eat(){ System.out.println(name+"正在吃"); } void eat(String food){ System.out.println(name+"正在吃"+food); } void eat(String food,int nu...
多态本质：多个对象共享同一接口 多态本质是共享接口
diaoju3333的博客
01-17 254
所谓的多态是将类似的不同实现统一到一个（组）接口的能力； 涉及到两个方面：1）抽象能力；2）面向接口（忽略载体、对象）。 Polymorphism is the ability of the programmer to write methods of the same name that do different things for different types of o...
不一样的多态
weixin_33735077的博客
07-06 91
一样的多态 多态（Polymorphism）一词源于生物学，顾名思义就是指多种形态。在面向对象世界里，多态与继承和封装一起构成了三大核心概念。 在.NET中，多态通常意味着子类对于父类一种衍变。子类继承自父类，拥有父类所定义的一切（public或protected）成员。但同时，它又可以修改（重写或复写）这些成员，使其实现与父类以及其他子类完全不同。我们可以说，继承体现了类的多态性。 大家应...
Java多态
weixin_44722819的博客
06-19 343
目录一、多态的概念1.1 什么是多态1.2 多态的实现格式二、举例 一、多态的概念 1.1 什么是多态 多态：同样的引用调用同样的方法却做了不同的事情。 通俗来讲，多态就是指一个事物有不同表现形式。比如水有固态，液态，气态三种形态。 1.2 多态的实现格式 父类类型 对象名=new 子类名称（）； 注： 父类类型：指子类对象继承的父类类型，或者实现的父接口类型。 例如： //Teacher继承自Person类 Person peo=new Teacher() 二、举例 在Java中实现多态，一般使用一个父
labview创建多态VI
09-19
创建多态VI在LabVIEW中的实现主要依赖于函数选板（Function Palette）上的数据类型结构（Data Type Structure）。下面将详细介绍如何在LabVIEW中创建和使用多态VI。 1. **定义多态VI的基本结构** 在LabVIEW中，一...
多态VI-综合文档
05-23
在LabVIEW（Laboratory Virtual Instrument Engineering Workbench）环境中，多态VI（Virtual Instruments）提供了类似的功能，使得开发者可以创建更加灵活、可扩展的代码结构。本文将深入探讨多态VI的概念、工作...
类的多态练习_C++_类的多态练习_
09-29
首先，我们要明白多态性的两种主要形式：静态多态（Static Polymorphism）和动态多态（Dynamic Polymorphism）。静态多态主要通过函数重载（Function Overloading）和运算符重载（Operator Overloading）实现，...
Java 语言程序设计：第5章接口多态.ppt
09-20
Java 语言程序设计第 5 章接口多态 本章主要讲解 Java 语言程序设计中接口和多态的概念、语法和应用。接口是 Java 语言中的一种抽象机制，它提供了一种定义类之间的“协议”的方式，允许类之间实现多继承，同时免除...
多态代码实例
04-10
在编程领域，多态（Polymorphism）是一个关键概念，尤其在面向对象编程中发挥着重要作用。多态允许我们使用一个通用的接口来处理不同类型的对象，提供了代码的灵活性和可扩展性。虚函数（Virtual Function）是实现...
多态实现主人喂养宠物
weixin_30463341的博客
07-27 3777
/* 多态实现主人喂养宠物 */ package day_7; public class Pet { public void eat(){ System.out.println("***********宠物在吃**********"); } } package day_7; public class Dog extends...
无人机集群分层通信及连通性研究
10-18
针对强干扰环境，在采用窄波束固定安装的通信模块执行任务的过程中，采用一种无人机集群分层通信与连通性判断的方法，通过上下层无人机两两之间的通信关系，确定无人机集群的连通性。局部信息在集群中多次中转实现整体的信息共享，为绕飞搜索、队形保持、防止碰撞等措施的实现提供信息支持，是执行高风险、高难度复杂任务的一种高可靠、低成本的 方案。
花旗杯金融创新应用大赛——基于机器学习的上市公司信息披露质量评价系统.zip
10-18
花旗杯金融创新应用大赛——基于机器学习的上市公司信息披露质量评价系统
PHP-032校园二手旧货闲置物品交易网站毕业课程源码设计+论文资料
最新发布
10-18
编号：332 校园二手闲置旧货信息网站，为校园二手闲置旧货交易提供了网上平台。如今，随着电子商务的不断发展完善，大学校园也需要一个能为学生提供旧货物品交易的专用网站，以便发布各种商品信息。 本设计具有一般电子商务的功能，且体现出校园风格。该系统提供的功能包括注册、查询信息、发布信息等。本系统的特点在于应用了PHP技术。它是一种简单的动态脚本语言，具有开放源码、执行速度快的特点。该技术还支持广泛的数据库连接 ，具有大量的扩展库，安全性能高，易学易用。 系统管理员模块包括：系统配置管理、会员信息管理、网站新闻管理、物品信息管理、管理员管理、登录日志管理。用户模块包括：安全登录、找回密码、查询信息、发布信息、会员注册、物品类别、物品信息管理、会员信息修改。刚进入网站的非会员能够在此网站浏览和搜索信息，不仅能浏览旧货信息还能浏览到热门信息。经过注册成为会员便能发布信息。此系统还考虑到用户利用穷举法破解密码，专门设置了用户和管理员登录日志，以便及时了解和防范。
rhino grasshoper 查看及统一曲面法线方向.gh
10-18
【rhino@grasshoper 查看及统一面法线方向】https://www.bilibili.com/video/BV1ZCWpeLE2h?vd_source=b420114c993138474d2e93d83ead77a5
DXGIDemo.zip
10-18
Qt中使用DXGI截取桌面图像并保存到本地。
计算台湾上市OTC公司英文可持续发展报告的声调得分.zip
10-18
计算台湾上市OTC公司英文可持续发展报告的声调得分
C++中的静态多态与动态多态解析
本文将探讨C++中的静态多态与动态多态，这两种多态形式在C++中扮演着重要角色，分别代表了编译期多态和运行期多态。动态多态主要通过虚函数实现，允许在运行时根据对象的实际类型调用相应的函数，而静态多态则主要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值