黑马程序员-④面向对象三大特性封装、继承、多态

----- <a href="http://www.itheima.com" target="blank">ios培训</a>、<a href="http://www.itheima.com" target="blank">ios培训</a>、期待与您交流！ ---------

1.封装概念

封装是对象和类概念的主要特性。它是隐藏内部实现，稳定外部接口，可以看作是“包装”。 封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。
好处：使用更加简单  变量更加安全 可以隐藏内部实现细节  开发速度加快。

继承的实现  在接口中使用符号“：”。
例如  @interface Student: NSObject{ }
注意：属性封装了实例变量，方法封装了具体的实现代码， 类封装了属性和方法。子类可以继承父类中的方法，还可以重写（override）父类的方法。

@interface就好像暴露在外面的时钟表面，像外界提供展示以及接口。@implementation就好像隐藏在时钟内部的构造实现，把具体的实现封装了起来。

2.封装的应用

在开发过程中，考虑到安全性要求，我们一般不在成员变量名前面使用@public、@protected等关键字修饰，而是使用Set方法来为对象提供成员变量的值。在set方法的内部也可以对一些不合理的赋值进行筛选过滤。

Set方法的作用：为外界提供一个设置成员变量值的方法
命名规范：
（1）方法名必须以set开头
（2）Set后面跟上成员变量的名称，首字母大写
（3）返回值一定是void
（4）一定要接收一个参数，而且参数类型需要和成员变量的类型一致
（5）形参名不能喝成员变量名一样（苹果官方推荐成员变量名前加_以示区分）
Set方法的好处：
（1）不让数据暴露在外，保证了数据的安全性

（2）对设置的数据进行过滤

Set方法的实现

Get方法的作用：为调用者返回对象内部的成员变量
命名规范：
（1）一定有返回值，返回值的类型和成员变量的类型一致
（2）方法名和成员变量名一样
（3）不需要接收任何参数

<span style="font-size:14px;">#import<Foundation/Foundation.h>
@interface Student : NSObject
{int age;
}
- (void)setAge:(int)newAge
- (int)age;
@end

@implementation Student

// set方法的实现
- (void)setAge:(int)newAge
{
    // 对传进来的参数进行过滤
    if (newAge <= 0)
    {
        newAge = 1;
    }
    age = newAge;
}

- (int)age
{
    return age;
}
@end

int main()
{
    Student *stu = [Student new];
    [stu setAge:15];
    NSLog(@"学生的年龄是%d岁", [stu age]);
    return 0;
}</span>

注意1：在实际的开发中，不一定set和get方法都会提供，如果内部的成员变量比如学生的学号这样的数据只允许外界读取，但是不允许修改的情况，则通常只提供get方法而不提供set方法。

注意2：成员变量名的命名以下划线开头，get方法名不需要带下划线，使用下划线开头有两个好处：

（1）与get方法的方法名区分开来；

（2）可以和一些其他的局部变量区分开来，下划线开头的变量，通常都是类的成员变量。

<span style="font-size:14px;">#import <Foundation/Foundation.h>
typedef enum {
    SexMan,
    SexWoman
} Sex;
@interface Student : NSObject
{
    int _no;
    Sex _sex;
}

// sex的set和get方法
- (void)setSex:(Sex)sex;
- (Sex)sex;

// no的set和get方法
- (void)setNo:(int)no;
- (int)no;
@end

@implementation Student

- (void)setSex:(Sex)sex
{
    _sex = sex;
}
- (Sex)sex
{
    return _sex;
}
- (void)setNo:(int)no
{
    _no = no;
}
- (int)no
{
    return _no;
}
@end
int main()
{
    Student *stu = [Student new];
    
    [stu setSex:SexMan];
    [stu setNo:15];
    NSLog(@"性别是：%d，学号是%d"，[stu sex]，[stu no])
    return 0;
}</span>

oc的弱语法

（1）：只有方法的声明，而没有方法的实现在编译阶段不会报错

OC在运行过程中才会检测对象有没有实现相应的方法

（2）：没有声明方法，直接在@implementation内部声明并实现了方法

 类方法

 1> 加号 + 开头

 2> 只能由类（名）来调用

 3> 类方法中不能访问成员变量（实例变量）

 类方法的好处：不依赖于对象，执行效率高

类方法的使用场合：（1）能用类方法，尽量用类方法。（2）当方法内部不需要使用到成员变量时，就可以改为类方法

<span style="font-size:14px;">#import <Foundation/Foundation.h>
@interface Person : NSObject
{
    int age;
}

// 类方法都是以加号开头
+ (void)printClassName;
@end

@implementation Person

+ (void)printClassName
{
  
    NSLog(@"这个类叫做Person的类方法");
}
@end

int main()
{
    [Person printClassName];
    return 0;
}</span>

可以允许类方法和对象方法同名，当使用类调用方法时，会调用带+号的该方法；而使用对象调用方法时，会调用带-号的方法。

<span style="font-size:14px;">#import <Foundation/Foundation.h>
@interface Person : NSObject
{
    int age;
}
- (void)test;
+ (void)test;

@end

@implementation Person
- (void)test
{
    NSLog(@"111-%d", age);
}
+ (void)test
{
    NSLog(@"333");
}
@end

int main()
{
    [Person test]; //调用类方法
    Person *p = [Person new];
    [p test];//条用对象方法
    return 0;
}</span>

Self的用途:

（1）Self是一个指针，谁调用了当前方法，self就指向谁。（出现在对象方法中，就代表着当前对象，出现在类方法中，就代表着当前类）
（2）[self 方法名]；可以调用其他的对象方法或者是类方法

<span style="font-size:14px;">#import <Foundation/Foundation.h>
@interface Dog : NSObject
- (void)bark;
- (void)run;
+ (void)run;
+ (void)bark;
@end

@implementation Dog
- (void)bark
{
    NSLog(@"汪汪汪");
}
- (void)run
{
    [self bark];//self代表对象方法
    NSLog(@"跑跑跑");
}
+ (void)bark
{
    NSLog(@"汪汪汪类方法");
}
}
+ (void)run
{
    [self bark];//self代表类方法
    NSLog(@"跑跑跑");
}
@end

int main()
{
    Dog *d = [Dog new];
    [d run];
    [Dog run];
    return 0;
}</span>

（3）可以利用self->成员变量名访问当前对象内部的成员变量（仅在对象方法中）

<span style="font-size:14px;">#import <Foundation/Foundation.h>
@interface Person : NSObject
{
    int _age;
}
- (void)setAge:(int)age;
- (int)age;
@end

@implementation Person
- (void)setAge:(int)age
{
    // _age = age;
    // self：指向了方向调用者,代表着当期对象
    self->_age = age;
}
- (int)age
{
    return self->_age;
}
@end</span>

self使用注意

<span style="font-size:14px;">- (void)test
{
    NSLog(@"调用了-test方法");
    
    // 会引发死循环
    //[self test];
}

+ (void)test
{
    NSLog(@"调用了+test方法");
    
    // 会引发死循环
    //[self test];
}</span>

1.继承的好处：

 1> 抽取重复代码

 2> 建立了类之间的关系

 3> 子类可以拥有父类中的所有成员变量和方法

 2.注意点

 1> 基本上所有类的根类是NSObject

<span style="font-size:14px;">/********Animal的声明*******/
@interface Animal : NSObject
@end

/********Animal的实现*******/
@implementation Animal
@end

/********Dog*******/
 Dog 继承了Animal，相当于拥有了Animal里面的所有成员变量和方法
 Animal称为Dog的父类
 Dog称为Animal的子类
@interface Dog : Animal
@end

@implementation Dog
@end</span>

 1.重写：子类重新实现父类中的某个方法，覆盖父类以前的做法

 2.注意

 (1)父类必须声明在子类的前面

 (2)子类不能拥有和父类相同的成员变量

 (3)调用某个方法时，优先去当前类中找，如果找不到，去父类中找

 3.坏处：耦合性太强

<span style="font-size:14px;">#import <Foundation/Foundation.h>
// Person
@interface Person : NSObject
- (void)run;
+ (void)test;
@end

@implementation Person
+ (void)test
{
    NSLog(@"调用了Person中test方法");
}
- (void)run
{
    NSLog(@"调用了person中run方法);
}
@end

// Student
@interface Student : Person
@end

@implementation Student
// 重写：子类重新实现父类中的某个方法，覆盖父类以前的做法
- (void)run
{
    NSLog(@"调用了student中run方法");
}
+ (void)test
{
    NSLog(@"调用了student中test方法");;
}
@end

int main()
{
    [Student test];//输出@"调用了student中test方法"
    [Person test];//输出@"调用了Person中test方法"
    Student *s = [Student new];
    [s run];//@"调用了student中run方法"
    
    return 0;
}</span>

1.继承的使用场合

 1. 当两个类拥有相同属性和方法的时候，就可以将相同的东西抽取到一个父类中

 2. 当A类完全拥有B类中的部分属性和方法时，可以考虑让B类继承A类

super的作用

 1.直接调用父类中的某个方法

 2.super处在对象方法中，那么就会调用父类的对象方法

   super处在类方法中，那么就会调用父类的类方法

 3.使用场合：子类重写父类的方法时想保留父类的一些行为

<span style="font-size:14px;">@interface Zoombie : NSObject
- (void)walk;
@end

@implementation Zoombie
- (void)walk
{
    NSLog(@"往前挪两步******");
}
@end

// 跳跃僵尸
@interface JumpZoombie : Zoombie
- (void)haha;
@end

@implementation JumpZoombie

- (void)walk
{
    NSLog(@"跳两下");
    [super walk];// 走两下(直接调用父类的walk方法)
}
@end

int main()
{
    JumpZoombie *jz = [JumpZoombie new];
    
    [jz walk];
    
    return 0;
}</span>

多态

 1.没有继承就没有多态

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

 3.好处：如果函数\方法参数中使用的是父类类型，可以传入父类、子类对象

 4.局限性：

 1> 父类类型的变量不能直接调用子类特有的方法。必须强转为子类类型变量后，才能直接调用子类特有的方法

/父类指针可以指向子类对象

<span style="font-size:14px;">    Animal *c = [Cat new];
    NSObject *n = [Dog new];
    NSObject *n2 = [Animal new];
    Dog *d = [Dog new]; // Dog类型
    Animal *a = [Dog new];//多态：父类指针指向子类对象
    [a eat];//调用方法时会检测对象的真实形象</span>

oc语言中字符串创建

<span style="font-size:14px;">#import <Foundation/Foundation.h>
int main()
{
    // 最简单的创建字符串的方式
    NSString *str = @"itcast";
    // length方法算的是字数
    int size = [str length];
    NSLog(@"%d", size);//输出str的长度
    
    // 创建OC字符串的另一种方式
    NSString *newStr = [NSString stringWithFormat:@"My age is %d and no is %d and name is %@", 23, 666, str];
    NSLog(@"---- %ld", [newStr length]);

    return 0;
}</span>