黑马程序员 ——ios点语法和类的三大特性

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

 一、点语法

（一）认识点语法

声明一个Fraction类:

#import <Foundation/Foundation.h>

@interface Fraction : NSObject

{

    int _numerator;

    int _demominator;

}

- (void) setNumerator:(int)numerator;

- (int) numerator;

- (void) setDemominator:(int)demominator;

- (int) demominator;

@end

　　　　Fraction类的实现：

 

#import "Fraction.h"

@implementation Fraction

- (void) setNumerator:(int)numerator

{

    _numerator = numerator;

}

- (int) numerator

{

    return _numerator;

}

- (void) setDemominator:(int)demominator

{

    _demominator = demominator;

}

- (int) demominator

{

    return _demominator;

}

@end

 

点语法的使用：

#import <Foundation/Foundation.h>

#import "Fraction.h"

int main(int argc, const char * argv[])

{

    @autoreleasepool {

    

        Fraction *fraction = [[Fraction allo] init];

        

        fraction.numerator = 10;//点语法，等效与[Fraction setNumerator:10];

        //这里并不是给fraction的属性赋值，而是调用fraction的setNumerator方法

    

        

        int num = fraction.numerator;//等效与int num = [fraction numerator]

        NSLog(@"num is %i", num);

        

    }

    return 0;

}

 

（二）点语法的作用

OC设计点语法的目的，是为了让其他语言的开发者可以很快的上手OC语言开发，使用点语法，让它和其他面向对象的语言如java很像。

（三）点语法的本质

点语法的本质是方法的调用，而不是访问成员变量，当使用点语法时，编译器会自动展开成相应的方法。切记点语法的本质是转换成相应的set和get方法，如果没有set和get方法，则不能使用点语法。

如：

fraction.numerator = 10;展开为：[fraction setNumerator:10];

int  num=fraction.numerator;展开为：int num = [fraction numerator];

编译器如何知道是set方法还是get方法？主要是看赋值（可以使用断点调试来查看）。

在OC中访问成员变量只有一种方式即使用-> 如fraction->_numerator，这种情况要求在@public的前提下。

（四）点语法的使用注意

下面的使用方式是一个死循环：

 　　(1)在set方法中，self.numeraor=numerator;

相当于是[self setNumerator:numerator];

(2)在get方法中，return self.numerator;相当于是[self numerator];

二、变量作用域

（一）变量的作用域主要分为四种：

（1）@public (公开的)在有对象的前提下，任何地方都可以直接访问。

（2）@protected （受保护的）只能在当前类和子类的对象方法中访问

（3）@private （私有的）只能在当前类的对象方法中才能直接访问

（4）@package (框架级别的)作用域介于私有和公开之间，只要处于同一个框架中就可以直接通过变量名访问

（二）使用注意和补充

（1）在类的实现即.m文件中也可以声明成员变量，但是因为在其他文件中通常都只是包含头文件而不会包含实现文件，所以在这里声明的成员变量是@private的。在.m中定义的成员变量不能喝它的头文件.h中的成员变量同名，在这期间使用@public等关键字也是徒劳的。

（2）在@interface  @end之间声明的成员变量如果不做特别的说明，那么其默认是protected的。

（3）一个类继承了另一个类，那么就拥有了父类的所有成员变量和方法，注意所有的成员变量它都拥有，只是有的它不能直接访问。

类的三大特性

1，类的封装

类的封装可以理解为：

一块表，我们只要能从中获取时间值对我门来说便已经足够，我们不必要知道它内部的运行方式。同理，我们设计一个类，没有必要让外界知道我们的内部实现，只要能满足外部需要的功能即可。

类封装的好处：

第一:重用;

我们可以在封装方法后，对象可以多次调用方法，而不用每次都去写该方法。

第二:不必关心具体的实现;

程序员只管直接使用。

第三:面向对象三大特征之一，

模块化，可以很好的区分及应用。类的封装时面向对象的基础概念风格，就是把每个对象的东西装在一起，如果像某些人说的把说有对象方法，都放在一个箱子里的话，那么将很难团队合作分工，改需求时也很难改。

第四,具有安全性

封装好后，我们并不知道类中是怎么实现的。只是简单的使用了该方法。

第五：

封装后可以修改类的内部实现，而无需修改使用了该类的客户代码（即坏了容易替换，不影响全局）

第六：

封装后可以对成员进行更精确的控制，例如将某个成员设置为只读的。

2.类的继承

继承的基本概念

我们想要创建一个猫类和一个狗类。猫类和狗类有一些相同的成员变量和对象方法，这种情况下，我们可以创建一个动物对象，让猫和狗都继承这个对象

声明部分如下：

#import <Foundation/Foundation.h>

@interface Animal : NSObject

{

    double _weight;

    int age;

}

- (void) setWeight:(double) weight andAge:(int)age;

- (void) print;

@end

#import "Animal.h"

@interface Dog : Animal

- (double) weight;

@end

#import "Animal.h"

@interface Cat : Animal

- (int) age;

@end

在狗类中增加了获取体重的方法，在猫类中增加了获取年龄的方法

继承的使用注意

（1）编译器从上往下执行，所以在子类前面至少应该要有父类的声明；

（2）OC中不允许子类和父类拥有相同名称的成员变量名；

（3）OC中的子类可以拥有和父类相同名称的方法，在子类调用时，优先去自己的内部寻找，如果没有则一层一层的往上找；

重写即子类重新实现了父类中的某个方法，覆盖了父类以前的实现。

继承和组合

继承的适用场合：

（1）当两个类拥有相同的属性和方法时，就可以将相同的属性和方法抽取到一个父类中。

（2）当A类完全拥有B类中的部分属性和方法时，可以考虑让B类继承A类（考虑），在这种情况下，也可以考虑使用组合。

继承：###是xxx,如狗是动物，可以让狗继承动物类

组合：###拥有xxx，如学生有书，可以让书这个类作为学生类的属性

 

关键字super

Super关键字，在子类中重写方法时，可以让调用者跳过这一层而调用父类中的方法。

作用：

（1）直接调用父类中的某一个方法

（2）Super处在对象方法中，那么就会调用父类的对象方法；super处于类方法中，那么就会调用父类的类方法。

使用场景：子类在重写父类方法时，想要保留父类的一些行为。

抽象类

有时，创建类知识使创建子类更容易。因此，这些类名为抽象类。比如，Foundation框架里的NSNumber类是为了将数字作为对象处理而创建的抽象类

三，类的多态

一、基本概念

多态在代码中的体现，即为多种形态，必须要有继承，没有继承就没有多态。

在使用多态是，会进行动态检测，以调用真实的对象方法。

多态在代码中的体现即父类指针指向子类对象。

#import <Foundation/Foundation.h>

@interface Animal : NSObject

- (void)eat;

@end

@implementation Animal

- (void)eat

{

    NSLog(@"吃东西");

}

@end

@interface Dog : Animal

- (void)eat;

@end

@implementation Dog

- (void)eat

{

    NSLog(@"狗在吃东西");

    [super eat];

}

@end

int main(int argc, const char * argv[]) {

    @autoreleasepool {

        

        //父类执政指向子类对象

        Animal *a = [[Dog alloc] init];

        

        [a eat];

    }

    return 0;

}

 

多态使用总结

（1）没有继承就没有多态

（2）代码的体现：父类类型的指针指向子类对象

（3）好处：如果函数方法参数中使用的是父类类型，则可以传入父类和子类对象，而不用再去定义多个函数来和相应的类进行匹配了。

（4）局限性：父类类型的变量不能直接调用子类特有的方法，如果必须要调用，则必须强制转换为子类特有的方法。

转载于:https://www.cnblogs.com/frozen1224/p/4238505.html