iOS开发-Day22-OC 延展和协议以及深浅复制

1、什么是延展（extension）

我们定义类时说在.h里写的变量如果不是public一般不能被直接调用需要用方法，而定义的所有方法都可以被调用，但是如果我有的方法不想被外部调用只给内部使用呢？至此，延展出现。

从上可知，延展就是类似于“定义私有方法”的一种子类。

2、延展的注意事项

a：可以不通过创建文件来创建延展，可以直接在.m文件里写@interface和@implementation，注意这两个都要写在.m文件里，因为如果把@interface写在.h里，那么里面的方法都是public的；

b：可以直接省略@interface，直接在.m文件里写方法即可，但是建议书写，至少阅读起来在文件一开始的几行就告知了哪些是私有方法。

延展的例子

//  Student.h
#import <Foundation/Foundation.h>
@interface Student : NSObject
//声明student的两属性
@property(strong,nonatomic)NSString *name;
@property(assign,nonatomic)int age;
@end

//  Student.m
#import "Student.h"
#import "Student_StudentExt.h"
@implementation Student
//实现拓展中得sayHi方法
-(void)sayHi
{
NSLog(@"hi");
}
//在初始化时调用sayHi方法
- (instancetype)init
{
self = [super init];
if (self) {
[self sayHi];
}
return self;
}
@end

//  Student_StudentExt.h
#import "Student.h"
@interface Student ()
//在student的拓展中声明sayHi方法
-(void)sayHi;
@end

还可以省去延展的声明和实现文件，在被延展类实现中这样写：

//  Student.m
#import "Student.h"
//延展Student
@interface Student ()
//在student的拓展中声明sayHi方法
-(void)sayHi;
@end
@implementation Student
//实现拓展中得sayHi方法
-(void)sayHi
{
NSLog(@"hi");
}
//在初始化时调用sayHi方法
- (instancetype)init
{
self = [super init];
if (self) {
[self sayHi];
}
return self;
}
@end

更多内容可以看到这里/article/1373663.html

3、协议的含义

OC中的协议就是相当于Java中的接口(抽象类)，只不过OC中的名字更形象点，因为我们在学习Java中的接口时候，看可以知道其实接口就相当于一种契约(协议)，给他的实现类打上标记了。

协议就是定义了一组方法，然后让其他类去实现

4、协议的定义格式：

@protocol  协议名  <父协议>
定义方法
@end
注：定义协议的关键字是@protocol,同时协议也是可以继承父协议的

协议中定义的方法还有两个修饰符：
@required：这个表示这个方法是其他类必须实现的，也是默认的值
@optional：这个表示这个方法对于其他类实现是可选的

5、协议的使用

使用协议很简单，直接在继承类(如NSObject)后面 <协议名>
之后在对应类的实现文件中实现协议的所有必须类即可。

6、检查对象是否遵循协议，对应类是否实现协议中的方法：

[对象 conformsToProtocol:@protocol(协议)];
[对象 respondsToSelector:@selector(方法)];

下面看一个简单例子：

//  SDZY.h
#import <Foundation/Foundation.h>
//声明SDZY协议，包含work方法
@protocol SDZY <NSObject>
-(void)work;
@end

//  Student.h
#import <Foundation/Foundation.h>
#import "SDZY.h"
//Student遵循SDZY协议
@interface Student : NSObject<SDZY>
@end

//  Student.m
#import "Student.h"
@implementation Student
//实现协议中得work方法
-(void)work
{
NSLog(@"i study everyday!");
}
@end

//main.m
Student *stu=[Student new];
//检查stu是否遵循SDZY协议
if ([stu conformsToProtocol:@protocol(SDZY)]) {
//检查stu是否实现work方法
if ([stu respondsToSelector:@selector(work)]) {
//如果实现则调用work方法
[stu work];
}else{
//否则输出日志
NSLog(@"stu don't work");
}
}else{
//未遵循协议时输出日志
NSLog(@"stu don't follow YiXin&SDZY protocal");
}

7、关于深浅复制

首先，什么是深浅复制？

在复制操作时，对于对象有n层是对象复制，我们可称作n级深复制，此处n应大于等于1。
浅 复 制：在复制操作时，对于被复制的对象的每一层复制都是指针复制。
深 复 制：在复制操作时，对于被复制的对象至少有一层复制是对象复制。
完全复制：在复制操作时，对于被复制的对象的每一层复制都是对象复制。指针复制俗称指针拷贝，对象复制也俗称内容拷贝。

不同关键字

retain：始终是浅复制。引用计数每次加一。返回对象是否可变与被复制的对象保持一致
copy：对于可变对象为深复制，引用计数不改变;对于不可变对象是浅复制，引用计数每次加一，始终返回一个不可变对象。
mutableCopy：始终是深复制，引用计数不改变。始终返回一个可变对象。

什么时候用到深浅拷贝

深拷贝是在要将一个对象从可变（不可变）转为不可变（可变）或者将一个对象内容克隆一份时用到；
浅拷贝是在要复制一个对象的指针时用到。

更多详细可以看这里：/article/4706666.html

一个完整验证深浅复制的实例：

//
//  main.m
//  OC深浅copy
//
//  Created by 严诚 on 15/8/11.
//  Copyright (c) 2015年 严诚. All rights reserved.
//

#import <Foundation/Foundation.h>

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

//===========================第一种：非容器类不可变对象==================

NSString *str1=@"one day";

printf("\n初始化赋值引用计数为::::%lu",str1.retainCount);

NSString *strCopy1=[str1 retain];

printf("\n继续retain引用计数为:::%lu",str1.retainCount);

NSString *strCopy2=[str1 copy];

printf("\n继续copy后引用计数为::::%lu",str1.retainCount);

NSString *strCopy3=[str1 mutableCopy];

printf("\n继续mutableCopy后为:::%lu\n",str1.retainCount);

NSString *newstr=str1;

printf("\n非容器类不可变对象\n原始地址::::::::::%p",str1);

printf("\nretain复制::::::::%p",strCopy1);

printf("\ncopy复制::::::::::%p",strCopy2);

printf("\nmutableCopy复制:::%p",strCopy3);

printf("\n=号赋值的情况::::%p",newstr);

//这里说明该类型不存在引用计数的概念

// 初始化赋值引用计数为：18446744073709551615

// 继续retain引用计数为：18446744073709551615

// 继续copy后引用计数为：18446744073709551615

// 继续mutableCopy后为：18446744073709551615

//                        小提示：这里很多人都说是赋值，所以就好解释这里没引用计数的概念。而且也能解释为什么
//
//                        NSString *strCopy2=[str1 copy];
//
//                        NSMutableString  *strCopy2=[str1 copy];
//
//                        这样都不会报错的原因了。那既然只是简单赋值为什么要这么麻烦呢，直接
//
//                        NSString *strCopy2=*str1;
//
//                        NSMutableString  *strCopy2=*str1;
//
//                        其实大家都看出来了，这里是指针变量，只存在“指针的复制”，
//
//                        跟赋值概念完全不同，虽然这里看起来很像。
//
//                        原来该类型是字符串常量时，系统会为我们优化，声明了多个字符串，
//
//                        但是都是常量，且内容相等，那么系统就只为我们申请一块空间。
//
//                        疑问： 深复制=浅复制+赋值吗？
//
//                        赋值过程：输入数据→寄存器处理→开辟内存→写入数据。
//
//                        一次深复制，可以得到被复制对象指针，并进行一次赋值操作。

//非容器类不可变对象

//原始地址::::::::::0x1000033d0

//retain复制::::::::0x1000033d0//浅复制

//copy复制::::::::::0x1000033d0//浅复制

//mutableCopy复制:::0x10010c420//深复制

//=号赋值的情况::::原地址//浅复制

printf("\n");

//          ==============================第二种：容器类不可变对象=================

NSArray *array1= [NSArray arrayWithObjects:@"a",@"b",@"c",@"d",nil];

printf("\n初始化赋值引用计数为::::::::::::%lu",array1.retainCount);

NSArray *arrayCopy1 = [array1 retain];

printf("\n继续retain后引用计数为:::::::::%lu",array1.retainCount);

NSArray *arrayCopy2 = [array1 copy];

printf("\n继续copy后引用计数为:::::::::::%lu",array1.retainCount);

NSArray *arrayCopy3 = [array1 mutableCopy];

printf("\n继续mutableCopy后引用计数为::::%lu\n",array1.retainCount);

printf("\n容器类不可变数组\n原始地址::::::::::%p\t\t%p",array1,[array1 objectAtIndex:1]);

printf("\nretain复制::::::::%p\t%p",arrayCopy1,[arrayCopy1 objectAtIndex:1]);

printf("\ncopy复制::::::::::%p\t%p",arrayCopy2,[arrayCopy2 objectAtIndex:1]);

printf("\nmutableCopy复制:::%p\t%p",arrayCopy3,[arrayCopy3 objectAtIndex:1]);

//初始化赋值引用计数为::::::::::::1

//继续retain后引用计数为:::::::::2

//继续copy后引用计数为:::::::::::3

//继续mutableCopy后引用计数为::::3

//容器类不可变数组

//原始地址::::::::::0x10010c6b0 0x100003410

//retain复制::::::::0x10010c6b0 0x100003410//浅复制

//copy复制::::::::::0x10010c6b0 0x100003410//浅复制

//mutableCopy复制:::0x10010c760 0x100003410//深复制

printf("\n");

//        ===============第三种：非容器类可变对象==================

NSMutableString *str2=[NSMutableString stringWithString:@"two day"];

printf("\n初始化赋值引用计数为::::::::::::%lu",str2.retainCount);

NSMutableString *strCpy1=[str2 retain];

printf("\n继续retain后引用计数为:::::::::%lu",str2.retainCount);

NSMutableString *strCpy2=[str2 copy];

printf("\n继续copy后引用计数为:::::::::::%lu",str2.retainCount);

NSMutableString *strCpy3=[str2 mutableCopy];

printf("\n继续mutableCopy后引用计数为::::%lu\n",str2.retainCount);

printf("\n非容器类可变对象\n原始地址::::::::::%p",str2);

printf("\nretin复制::::::::%p",strCpy1);

printf("\ncopy复制::::::::::%p",strCpy2);

printf("\nmutableCopy复制:::%p",strCpy3);

//初始化赋值引用计数为::::::::::::1

//继续retain后引用计数为:::::::::2

//继续copy后引用计数为:::::::::::2

//继续mutableCopy后引用计数为::::2

//非容器类可变对象

//原始地址::::::::::0x10010c560

//retain复制::::::::0x10010c560//浅复制

//copy复制::::::::::0x100102720//深复制

//mutableCopy复制:::0x10010c880//深复制

printf("\n");

//        =========================第四种：容器类可变对象======================

NSMutableArray *array2   = [NSMutableArray arrayWithObjects:@"aa",@"bb",@"cc",@"dd",nil];

printf("\n初始化赋值引用计数为::::::::::%lu",array2.retainCount);

NSMutableArray *arrayCpy1 = [array2 retain];

printf("\n继续retain后引用计数为:::::::%lu",array2.retainCount);

NSMutableArray *arrayCpy2=[array2 copy];

printf("\n继续copy后引用计数为:::::::::%lu",array2.retainCount);

NSMutableArray *arrayCpy3 = [array2 mutableCopy];

printf("\n继续mutableCopy后引用计数为::%lu\n",array2.retainCount);

printf("\n容器类可变数组\n原始地址:::::::::::%p\t%p",array2,[array2 objectAtIndex:1]);

printf("\nretain复制:::::::::%p\t%p",arrayCpy1,[arrayCpy1 objectAtIndex:1]);

printf("\ncopy复制:::::::::::%p\t%p",arrayCpy2,[arrayCpy2 objectAtIndex:1]);

printf("\nnmutableCopy复制:::%p\t%p",arrayCpy3,[arrayCpy3 objectAtIndex:1]);

//初始化赋值引用计数为::::::::::1

//继续retain后引用计数为:::::::2

//继续copy后引用计数为:::::::::2

//继续mutableCopy后引用计数为::2

//容器类可变数组

//原始地址:::::::::::0x10010e6c0 0x1000034b0

//retain复制:::::::::0x10010e6c0 0x1000034b0//浅复制

//copy复制:::::::::::0x10010e790 0x1000034b0//深复制

//nmutableCopy复制:::0x10010e7c0 0x1000034b0//深复制

}
return 0;
}