动态类型调用方法的参数和返回值

最新推荐文章于 2022-10-13 19:33:15 发布
最新推荐文章于 2022-10-13 19:33:15 发布
阅读量842 收藏
点赞数
分类专栏： oc语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kobebryant16/article/details/44491797
版权

分数类

#import <Foundation/Foundation.h>

@interface Fraction : NSObject

@property int numerator,denominator;

-(void) print;
-(double) convertToNum;
-(void) setNumerator:(int)n andDenominator:(int)d;
-(Fraction *) add:(Fraction *)f;
-(Fraction *) sub:(Fraction *)f;
-(Fraction *) mul:(Fraction *)f;
-(Fraction *) div:(Fraction *)f;
-(void) reduce;
@end
#import "Fraction.h"

@implementation Fraction

@synthesize numerator,denominator;

-(void) print;
{
    NSLog(@"%i/%i",self.numerator,self.denominator);
}
-(double) convertToNum
{
    if (self.denominator!=0) {
        return (double)self.numerator/self.denominator;
    }
    else
        return NAN;
}
-(void) setNumerator:(int)n andDenominator:(int)d
{
    self.numerator=n;
    self.denominator=d;
}
-(Fraction *) add:(Fraction *)f
{
    Fraction *result=[[Fraction alloc] init];
    result.numerator=self.numerator*f.denominator+self.denominator*f.numerator;
    result.denominator=self.denominator*f.denominator;
    [result reduce];
    return result;
}
-(Fraction *) sub:(Fraction *)f
{
    Fraction *result=[[Fraction alloc] init];
    result.numerator=self.numerator*f.denominator-self.denominator*f.numerator;
    result.denominator=self.denominator*f.denominator;
    [result reduce];
    return result;
}
-(Fraction *) mul:(Fraction *)f
{
    Fraction *result=[[Fraction alloc] init];
    result.numerator=self.numerator*f.numerator;
    result.denominator=self.denominator*f.denominator;
    [result reduce];
    return result;
}
-(Fraction *) div:(Fraction *)f
{
    Fraction *result=[[Fraction alloc] init];
    result.numerator=self.numerator*f.denominator;
    result.denominator=self.denominator*f.numerator;
    [result reduce];
    return result;
}
-(void) reduce
{
    int u,v,temp;
    u=self.numerator;
    v=self.denominator;
    while (v!=0) {
        temp=u%v;
        u=v;
        v=temp;
    }
    self.numerator/=u;
    self.denominator/=u;
}
@end
复数类 

#import <Foundation/Foundation.h>

@interface Complex : NSObject

@property double real,imaginary;

-(void) print;
-(void) setReal:(double)r andImaginary:(double)i;
-(Complex *) add:(Complex *)c;
-(Complex *) sub:(Complex *)c;
-(Complex *) mul:(Complex *)c;
-(Complex *) div:(Complex *)c;
@end
#import "Complex.h"

@implementation Complex

@synthesize real,imaginary;

-(void) print
{
    NSLog(@"%g+%gi",self.real,self.imaginary);
}
-(void) setReal:(double)r andImaginary:(double)i
{
    self.real=r;
    self.imaginary=i;
}
-(Complex *) add:(Complex *)c
{
    Complex *result=[[Complex alloc] init];
    result.real=self.real+c.real;
    result.imaginary=self.imaginary+c.imaginary;
    return result;
}
-(Complex *) sub:(Complex *)c
{
    Complex *result=[[Complex alloc] init];
    result.real=self.real-c.real;
    result.imaginary=self.imaginary-c.imaginary;
    return result;
}
-(Complex *) mul:(Complex *)c
{
    Complex *result=[[Complex alloc] init];
    result.real=self.real*c.real;
    result.imaginary=self.imaginary*c.imaginary;
    return result;
}
-(Complex *) div:(Complex *)c
{
    Complex *result=[[Complex alloc] init];
    result.real=self.real/c.real;
    result.imaginary=self.imaginary/c.imaginary;
    return result;
}
@end
多态
不同的类可以定义同名的方法 如下 
        Fraction *f1=[[Fraction alloc] init];
        Fraction *f2=[[Fraction alloc] init];
        Fraction *f3;
        Complex *c1=[[Complex alloc] init];
        Complex *c2=[[Complex alloc] init];
        Complex *c3;
        [f1 setNumerator:1 andDenominator:10];
        [f2 setNumerator:2 andDenominator:15];
        [c1 setReal:18 andImaginary:2.5];
        [c2 setReal:-5 andImaginary:3.2];
        f3=[f1 add:f2];
        c3=[c1 add:c2];
        [f3 print];
        [c3 print];
2015-03-20 13:12:48.074 TTTTTT[585:303] 7/30
2015-03-20 13:12:48.076 TTTTTT[585:303] 13+5.7i
Fraction类和Complex类都有add方法和print方法 根据对象所属的类 调用相对应的方法
动态类型（即id类型）
id类型其实就是一个指针 该指针可以存放任何类的对象
动态绑定
动态绑定其实质是 声明为id类型的对象 在编译时无法确定究竟存放了哪个类的对象 直到程序运行时才确定 还是那句话 根据id对象存放的对象所属的类 动态调用相对应的方法 如下 
        id result;
        result=[f1 add:f2];
        [result print];
        result=[c1 add:c2];
        [result print];

2015-03-20 13:12:48.078 TTTTTT[585:303] 7/30
2015-03-20 13:12:48.079 TTTTTT[585:303] 13+5.7i
动态类型调用方法需要注意一下几点
1、如果在多个类中具有同名方法 方法与方法之间的参数类型必须保持一致 返回值也必须保持一致性 一致性指的是 int对int double对double 指针对指针 否则编译器会报错 比如加入Calculator类 Calculator类中的add:方法-(double) add:(double)value与上面两个类的add:方法在参数和返回值上没有保持一致
2、在保持一致性的前提下 如果参数是静态类型 编译器仍旧会发出警告 因为编译器只认最先进入的那个头文件中的add:方法 如下 
#import "Fraction.h"
#import "Complex.h"
        id resultFraction,resultComplex,result;
        resultFraction=[f1 add:f2];
        resultComplex=[c1 add:c2];
        [resultFraction print];
        [resultComplex print];
        
        resultFraction=[resultFraction add:f1];
        resultComplex=[resultComplex add:c1];
        [resultFraction print];
        [resultComplex print];
2015-03-20 13:09:46.029 Meature[549:303] 7/30
2015-03-20 13:09:46.032 Meature[549:303] 13+5.7i
2015-03-20 13:09:46.033 Meature[549:303] 1/3
2015-03-20 13:09:46.034 Meature[549:303] 31+8.2i
最先进入的是Fraction头文件 所以编译器在遇到[resultComplex add:c1]会发出警告 表示不兼容的指针类型 Complex类型送入到Fraction类型参数之中 其实这里没有任何问题
3、如果参数也是id类型 那么编译器就不会发出警告 因为编译器不知道送入的指针类型 如下 
        result=[resultFraction add:resultFraction];
        [result print];
        result=[resultComplex add:resultComplex];
        [result print];
2015-03-20 13:09:46.034 Meature[549:303] 2/3
2015-03-20 13:09:46.035 Meature[549:303] 62+16.4i
关于类的问题
[对象 class]
获取当前对象的类对象 既可用于实例对象 也可用于类对象 如下 
        Class c=[f1 class];
        NSLog(@"%@",c);
        c=[Fraction class];
        NSLog(@"%@",c);
        NSLog(@"%@",[c1 class]);
        NSLog(@"%@",[Complex class]);
2015-03-20 17:05:15.634 TTTTTT[1098:303] Fraction
2015-03-20 17:05:15.635 TTTTTT[1098:303] Fraction
2015-03-20 17:05:15.636 TTTTTT[1098:303] Complex
2015-03-20 17:05:15.637 TTTTTT[1098:303] Complex
@selector(方法)
既可用于实例方法 也可用于类方法 如下 
        SEL s=@selector(setNumerator:andDenominator:);
        NSLog(@"%@",NSStringFromSelector(s));
        NSLog(@"%@",NSStringFromSelector(@selector(setReal:andImaginary:)));
2015-03-20 17:05:15.639 TTTTTT[1098:303] setNumerator:andDenominator:
2015-03-20 17:05:15.640 TTTTTT[1098:303] setReal:andImaginary:
-(BOOL) isMemberOfClass:classObj 是否是classObj类的实例
-(BOOL) isKindOfClass:classObj 是否是classObj类或其子类的实例
+(BOOL) isSubclassOfClass:classObj 是否是classObj类的子类
+-(BOOL) respondsToSelector:selector 对象是否可以响应selector方法
+(BOOL) instancesRespondToSelector:selector 类的实例是否可以响应selector方法
其中respondsToSelector:既是实例方法又是类方法
方法包括从父类继承的方法 
        Square *squa=[[Square alloc] init];
        NSLog(@"%@",[squa isMemberOfClass:[Square class]]?@"YES":@"NO");
        NSLog(@"%@",[squa isMemberOfClass:[Rectangle class]]?@"YES":@"NO");
        NSLog(@"%@",[squa isMemberOfClass:[NSObject class]]?@"YES":@"NO");
        NSLog(@"%@",[squa isKindOfClass:[Square class]]?@"YES":@"NO");
        NSLog(@"%@",[squa isKindOfClass:[Rectangle class]]?@"YES":@"NO");
        NSLog(@"%@",[squa isKindOfClass:[NSObject class]]?@"YES":@"NO");
        NSLog(@"%@",[Square isSubclassOfClass:[Rectangle class]]?@"YES":@"NO");
        NSLog(@"%@",[Square isSubclassOfClass:[NSObject class]]?@"YES":@"NO");
        NSLog(@"%@",[squa respondsToSelector:@selector(setSide:)]?@"YES":@"NO");
        NSLog(@"%@",[squa respondsToSelector:@selector(setWidth:andHeight:)]?@"YES":@"NO");
        NSLog(@"%@",[Square respondsToSelector:@selector(alloc)]?@"YES":@"NO");
        NSLog(@"%@",[Square instancesRespondToSelector:@selector(setSide:)]?@"YES":@"NO");
        NSLog(@"%@",[Square instancesRespondToSelector:@selector(setWidth:andHeight:)]?@"YES":@"NO");
2015-03-20 18:59:30.450 Rectangle[1194:303] YES
2015-03-20 18:59:30.451 Rectangle[1194:303] NO
2015-03-20 18:59:30.453 Rectangle[1194:303] NO
2015-03-20 18:59:30.453 Rectangle[1194:303] YES
2015-03-20 18:59:30.454 Rectangle[1194:303] YES
2015-03-20 18:59:30.455 Rectangle[1194:303] YES
2015-03-20 18:59:30.456 Rectangle[1194:303] YES
2015-03-20 18:59:30.456 Rectangle[1194:303] YES
2015-03-20 18:59:30.457 Rectangle[1194:303] YES
2015-03-20 18:59:30.458 Rectangle[1194:303] YES
2015-03-20 18:59:30.458 Rectangle[1194:303] YES
2015-03-20 18:59:30.459 Rectangle[1194:303] YES
2015-03-20 18:59:30.459 Rectangle[1194:303] YES
接受者为类的方法之中 类也可以通过class方法来获取[squa class]或[Square class]
kobebryant16
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
函数参数---动态参数
weixin_33670786的博客
01-09 637
形参的第三种:动态参数 动态参数分为两种: 　　1.动态接受位置参数; 　　注意:形参的顺序: 位置参数, 动态参数, 默认参数 　　动态接受参数的时候要注意:动态参数必须在位置参数后面 　　关键参数必须要放在位置参数后边 　　最终顺序: 　　　　　位置参数>*args(动态位置参数)>默认参数>**kwargs(动态默认参数) 　　　　这四种参数可以任意...
动态调用API源码可取返回值可传递多参数
08-19
动态调用API源码可取返回值可传递多参数系统结构:载入动态链接库_,取进程地址_,释放动态链接库_,载入动态链接库_,取进程地址_,释放动态链接库_,呼叫窗口函数地址_,载入动态链接库
动态SQL 返回值
lengjing126的专栏
09-07 494
IF EXISTS(SELECT * FROM SYSOBJECTS WHERE NAME = 'ValueFromSql') DROP PROC ValueFromSql GO create proc ValueFromSql as begin declare
springmvc 动态修改返回值类型，实现方法既能被ajax调用，又能被同步请求调用...
weixin_33705053的博客
11-20 240
2019独角兽企业重金招聘Python工程师标准>>> ...
java代码-方法参数和返回值
07-14
理解如何正确地定义和使用方法参数和返回值是编写高效、可读性强的Java代码的关键。以下是对这个主题的详细探讨。 ### 1. 方法参数 方法参数是在调用方法时传递给方法的值。这些值在方法内部可以被用来执行相应的...
对python3 中方法各种参数和返回值详解
09-19
其中，函数（或称为方法）是构成 Python 程序的基本单元之一，而函数参数和返回值的设计则是理解和使用函数的关键。本文将深入探讨 Python3 中函数的各种参数类型及其返回值处理方式。 #### 函数概述 函数是一种可...
3 种方法实现参数的"动态"变化
潇洒程序员的专栏
10-06 1501
方法一： 比较常规的，利用template模板，在编译期替换参数   方法二： 利用指针，将函数的参数设置为 void* ，具体调用时，再做指针的强制类型转换 比如 void  fn(void* pVoid) {     int i =*(int *)pVoid; //先把它转换为想要的类型，再取它的内容；   ................ .................
java反射-动态调用方法(无参无返回值、有参无返回值、有参有返回值)
一起coding，一起嗨。
10-13 4013
【代码】java反射-动态调用方法(无参无返回值、有参无返回值、有参有返回值)
反射获取方法参数及返回值类型
热门推荐
pingyan158的专栏
10-23 1万+
package test;       import java.lang.reflect.Method;     import java.lang.reflect.ParameterizedType;     import java.lang.reflect.Type;     import java.util.List;  import java.util.Map;    pub
JAVA中通过反射机制获取方法的修饰符，返回值类型，方法名，形参列表
qq_42843172的博客
07-11 1268
JAVA中通过反射机制获取方法的修饰符，返回值类型，方法名，形参列表 与Field中没太大区别： 获取修饰符列表 Modifier.toString(method.getModifiers()) 获取方法返回值类型 method.getReturnType().getSimpleName() 获取方法名 method.getName() 获取方法形参列表 Class[] parameterTypes = method.getParameterTypes(); for (Class param
Java泛型：利用泛型动态确认方法返回值类型
weixin_30347009的博客
07-17 2334
根据泛型类型动态返回对象 public <T extends PackObject> T unPackMessage(String interfaceCode, String respValue, Class<T> clazz, String sysType) throws IOException { log.info(">> un...
JVM：方法调用之动态类型语言支持。
孤芳不自赏
05-30 693
Java虚拟机的字节码指令集的数量从Sun公司的第一款Java虚拟机问世至JDK 7来临之前的十余年时间里，一致没有发生任何变化。随着JDK 7的发布，字节码指令集终于迎来了第一位新成员——invokedynamic指令。这条新增加的指令是JDK 7实现“动态类型语言”（Dynamically Typed Language）支持而进行的改进之一，也是为JDK 8可以顺理实现Lambda表达式做技术...
java 返回指定类型_java – 如何指定方法的返回类型,调用方法的对象的类型？
weixin_33355385的博客
02-12 841
使用泛型.public interface Inter {T someMethod();void someMethod2(T obj);}public class C1 implements Inter {public C1 someMethod() {// ..}public void someMethod2(C1 obj) {// ..}}public class C2 implements ...
mysql 动态sql 返回值_mysql存储过程 在动态SQL内获取返回值的方法详解
weixin_42355003的博客
02-07 1152
MySql通用分页存储过程过程参数p_cloumns varchar(500),p_tables varchar(100),p_where varchar(4000),p_order varchar(100),p_pageindex int,p_pagesize int,out p_recordcount int,out p_pagecount int$:begindeclare v_sqlcou...
java如何动态获取泛型参数的类型
海纳百川Android的博客
10-20 5760
Java如何动态获取泛型参数的类型 我们都知道java中的泛型其实是伪泛型，java在编译阶段会对变异类型进行擦除，擦出到泛型类的最小上限，编译后得到的class文件里面是没有任何泛型信息的，泛型的控制其实就是java编译器进行的控制，编译阶段进行泛型检查。那如果我们想在运行时知道泛型类的类型，如何做到呢？主要用到下面几个api： 1、public Type getGenericSuperclass()---Class类的方法 2、Type[] getActualTypeArguments()---P
引用一个具有相同参数和返回值类型的委托方法
最新发布
05-27
可以通过以下步骤来引用一个具有相同参数和返回值类型的委托方法： 1. 声明一个符合 Mydelegate2 委托类型的方法： ``` public void MyMethod(MyClass obj) { // do something } ``` 2. 创建一个 Mydelegate2 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值