了解OC/第一个OC程序/第一个面向对象程序的执行步骤

1.程序语言分类：
a.面向过程C （细节）
b.面向对象OC （整体）

2.第一个OC程序
注意创建项目的时候，type -> Foundation(OC), main.c  —> main.m, #include —> #import
#include同include一样，解决了重复导入的问题。
在OC项目中，是兼容C语言的程序，并且可以混搭。

 逻辑值数据类型：
BOOL isFlag = YES;  //OC中的布尔类型  YES 1  NO 0

程序中的对象是一片内存中的数据。

3.第一个面向对象程序
对象：对象是客观存在的，在计算机中，对象就是数据。
类：对象不是凭空出现的，要先设计经过一个过程，才变成对象，设计的内容就是类。
描述对象：属性（有什么）， 方法（能干什么）
实例化：类经过实例化才会变成对象。

4.第一个面向对象程序的执行步骤：
a.类
一个类有两个部分组成：*.h  *.m文件
（1）.h类的声明部分： 定义类的interface部分（声明）
@interface Student：NSObject
 @property int age；//声明属性
   - （void）study；  //声明方法
@end
（2）.m类的实现部分（定义）定义类的implemention部分（部分）
@implementation Student  //方法的定义、实现
- (void)study  { NSLog(@“执行了study方法”)；}
@end
b.实例化
类的实例化通常是写在main函数中的。
把内的信息从文件中加载到内存中。
#import “Student.h”
[Student alloc];  //实例化
Student *stu = [Student alloc];
c.对象
操作对象
对象.属性  stu.age = 18；
[对象 方法];  [stu study]; //*调用对象的方法，向对象发送信息。

5. 高内聚 低耦合
每个功能模块，尽可能的足够足够强大。
模块与模块之间的关系尽量松散。

6.属性
属性不能保存数据。实例变量才是真正保存数据的地方。
一个对象中的数值，真正保存在实例变量中。
通过方法可以操作实例变量，方法是操作实例变量的一种方法。
属性，属性也是访问实例变量的一种方式，更方便快捷。
（1） 属性的本质：
属性就是用来访问实例变量的。
一个属性标准由三个部分组成：
a.有一个对应的实例变量
b.属性有两个方法：
setter方法：- (void)set+”属性名并首字母大写”：(实例变量类型)参数名；
getter方法：- (实例变量名称)属性名；
c.点语法
对象.属性 = 18； 通过属性给实例变量赋值
int i = 对象.属性；通过属性得到实例变量的值
NSLog（对象.属性）;
（2）声明式属性：
a.实例变量
b.自动生成setter / getter方法  @property   @sythesize
c.点语法  
（3）IOS5中的属性
a.实例变量 自动生成
b.声明式属性  @property   @sythesize
c.点语法  
（4）IOS6中的属性
a.实例变量 略
b.声明式属性   @property保留   @sythesize略
c.点语法

7.声明式属性
(1)默认情况下，声明式属性并没有解决内存问题。
需要在声明属性的时候加上 retain（@property(retain)…）关键字来解决内存问题。
声明式属性只是解决setter/getter方法的内存问题，并不会处理dealloc中的内存问题，一个对象销毁时，要release其拥有的引用类型的实例问题。
(2)声明式属性的使用：
如果属性是引用类型，要使用retain关键字修饰。
@property(retain) TRBook *book;
如果属性是基本类型，要使用assign关键字修饰(默认).
@property(assign) int age;
如果属性是字符串，要使用copy关键字修饰。
@property(copy) NSString *name;
如果属性修饰为readonly，则只会生成getter方法。
如果属性修饰为getter = method, 对系统自动生成的getter方法名不满意，也可以通过该关键字修改getter方法名。

day02


一、初始化方法
创建一个对象的时候，一定要进行初始化，只需要给对象默认值，只需要调用无参的初始化方法。需要给对象一个指定的值，且需要调用有参的初始化方法。
初始化方法只是给实例变量(第一时间)赋值的一种方式。
[MyClass alloc];          int i;
?无参的初始化方法init    int i = 0;默认值
*有参的初始化方法initWith...   int i = 10;指定值
小结：访问实例变量有三种方式：
普通方法    随意
属性   简单
初始化方法   第一时间


二、方法
类只能调用类方法，实例方法只能通过实例调用。

1.方法有两种：
- (void)method;
实例方法：通过实例调用的方法，叫实例方法。
实例方法是通过“-”来定义的。
类方法：通过类调用的方法，叫类方法。
类方法是通过“+”来定义的。

2.类方法与实例方法的区别
类方法与实例无关，不可以调用实例变量或属性或方法。
实例方法与实例无关，可以调用实例变量或属性或方法。

3.类方法的时候
类方法主要是用来创建对象的。
类方法中，是可以访问类方法创建对象的实例变量或属性。
类方法中，可以使用self关键字，self关键字代表当前类，主要用来调用当前类中的其他类方法。

self关键字
在实例方法中代表当前实例；在类方法中代表当前类。

4.工厂方法
（工厂方法是类方法）
为了创建对象根简单，通过使用工厂方法。
工厂方法也分为两类：
无参的工厂方法：快速创建默认值的对象。
有参的工厂方法：快速创建指定值的对象。

TRMyClass
工厂方法名：是去掉类的前缀，类名小写。myClass
工厂方法实现：
//无参的工厂方法
+ (TRMyClass *)myClass{
return [[TRMyClass alloc] init];
}
//有参的工厂方法
+ (TRMyClass *)myClassWith …A… {
return [[TRMyClass alloc] initWith…A…];
}

小结：
标准的类中应该有：
（属性、普通方法（查看学生所有信息）、初始化方法、工厂方法)
属性(实例变量)  @property int age;
普通方法    -(void)show;
初始化方法   -(id)initWithAge:(int)age andSex:(char)sex;
工厂方法    +(TRStudent*)studentWithAge:(int)age andSex:(char)sex;
               
//  单例模式+(TRSingleton*)singleton;
单例方法：创建一个对象的工厂化方法 (面试呦！)

前面是：Data、Image、Video...
后面是：Center、Store
1) 调用：DataCenter *sharedDataCenter = [DataCenter sharedDataCenter];
2）单例的用途：全局的数据存储中心

```
必须会默写
DataCenter.h文件中声明创建单例方法
+ ( id )sharedDataCenter;

.m文件中实现创建单例方法

static sharedDataCenter *shareDataCenter = nil；

+ ( id )sharedDataCenter {
@synchronized(self){ //加锁
      if( sharedDataCenter == nil ) {
sharedDataCenter = [[sharedDataCenter alloc]init];
}
return sharedDataCenter;
   }
}

```
## 使用GCD来构建单例对象
步骤：
*1. 声明一个空的静态的单例对象
*2. 创建一个静态的GCD的单次任务Token
*3. 执行GCD的单次任务，dispatch_once, 任务就是单例对象的初始化语句。
*4. 返回创建好的单例对象。

```
+ (id)sharedDataCenter
{
   //*1.声明一个空的静态的单例对象 (static 表明在调用结束后空间不会被释放)
   static DataCenter *sharedDataCenter = nil;
   //*2. 创建一个静态的GCD的单次任务Token
   static dispatch_once_t onceToken;
   //*3. 执行GCD的单次任务，dispatch_once, 任务就是单例对象的初始化语句。
   dispatch_once(&onceToken,^{
       sharedDataCenter = [[self alloc]init];
   });
   //*4. 返回创建好的单例对象。
   return sharedDataCenter;
}
```


day03

1.内存管理原理：
在IOS开发中，有两种方式管理内存，一种是手动内存管理MRC，一种是自动内存管理ARC。
引用计数器：每个对象都有自己的引用计数器。
当发送alloc/copy/new消息的时候，会将该对象的引用计数器设为1.
当对象不再需要的时候，我们会向对象发送一个消息release，通知引用计数器减1。
当对象的引用计数器为0时，系统会自动销毁该对象，该对象在销毁前会自动执行dealloc消息。
当多个引用共用一个对象的时候，要记得通知引用计数器加1，发送retain消息。
    如果引用计数器使用不当，会发生两种情况：
1）如果引用计数器少加，会发生崩溃、crash。
2）如果引用计数器多加，会发生资源浪费、内存泄露。
   如果想查看当前对象的引用计数器的值，发送retainCount消息。

TRBook *book  = [[TRBook alloc]init];//RC:1
TRBook *book2 = book;//RC:1
//[book2 retain];
[book release];//RC:0
book2 野指针
[book2 release];

TRBook *book2 = [[TRBook alloc]init];//RC:1
[boo2 release];

项目默认的内存管理方式是ARC，需要手动进行修改。
Objective C Automatic Reference Counting —— NO
当对象的引用计数器为0时，立刻回收内存。
EditScheme —> Diagn… —> EnableZombie…  -------选中


2.面向对象的三大特性:
封装, 继承, 多态  （面试可能被提问）  

封装：把具体的实现放在.m文件中隐藏起来，只给外界访问公开接口
OC会把向外界公开的属性和方法放在头文件里，把不希望别人访问的属性和方法放在.m文件中隐藏起来


OC是单继承的，一个类只有一个父类。
C++是多继承的，一个类可以有多个父类。

NSObject是所有类的父类(老祖宗)
*.h 来描述 类与类之间的关系。
TRDog是子类，TRAnimal是父类。
@interface TRDog：TRAnimal
// 程序中依赖谁就先写谁的类。

1.继承：

1.1两个类之间的关系。
@interface   子类(Sub class) ：父类(Super class)
如果子类继承父类，那么子类将拥有父类所有的属性和方法。
如果子类对继承父类的方法不满意，子类可以重写父类的方法。
1.2.继承优缺点
a.提高了程序的复杂度（优点）
b.破坏了封装性
c.降低了可维护性与可扩展性
1.3.为什么使用继承
a.代码复制
b.制定规则（*）
c.多态（***）
1.4.弥补继承代码复用缺点
 组合  （共存亡一体的）苹果电脑  笔记本
 聚合  （弱依赖可拆卸）台式机  车与车轮
CPU   Computer

A.组合：
    组合的优点：
（1） 当前对象只能通过所包含的那个对象去调用其方法，所以所包含的对象的对象的内部细节对当前对象是不可见的。
（2）当前对象与包含对象是低耦合关系，如果修改包含对象的类的代码，不需要修改当前对象类的代码。
      组合的 缺 点：
只要创建computer对象，那么cpu对象一定会创建。
总结：computer与cpu共存亡  

B.聚合：
聚合的优点：
 （1）被包含的对象通过包含它们的类来访问
 （2）很好的封装
  （3）被包含的对象内部细节不可见。
  （4）可以在运行时动态定义聚合的方式
 聚合的 缺点：
   （1）系统可能会包含太多对象。
   （2）当使用不同对象时，必须小心定义的接口。

C.小结：
不论是组合与聚合都是描述类与类之间的 has a 关系。
共同点：
保留了封装性（可扩展性、可维护性...）
隐藏代码的实现部分
不同点：
组合：当前对象与包含对象，是强依赖，两者是不能替换的，共生死。一起创建一起销毁。
聚合：当前对象与包含对象，是弱依赖，两者是可替换的，并且生命周期是不一致的。

D.使用 ：
组合：代码不会经常维护，只是想快速使用。界面Controller、界面中元素View、创建Controller的时候，会同时创建View。
聚合：代码会经常维护或升级。


2.多态：
多种形态，引用的多态，方法的多种形态。
引用的多种形态：可以用父类的引用指向本类对象或子类对象。
方法的多种形态：当调用对象中的方法时，如果没有重写父类的方法，则调用的是父类的方法，如果重写了父类的方法，则调用的是子类的方法。
 注： 如果使用多态，只能调用子类从父类中继承的方法，不可以调用子类独有的方法。不可以使用子类的引用指向父类的对象。

使用：
（1）多态可以用于数组中。
（2）多态可以用于方法的参数。
（3）多态还可以用于方法的返回值类型。
屏幕快照 2015-05-17 下午4.07.18.png



day03

1.分类（Category）：
1.1分类也可以增强一个类的能力。
分类只能给待定的类添加能力。
1.2分类语法：
分类也是将代码信息保存到文件中。
.h 文件
@interface 主类类名（分类类名）
添加功能的声明部分
@end
.m 文件
@implementation 主类类名（分类类名）
添加功能的实现部分
@end
1.3使用
默认情况类不会添加分类的能力，只需要导入分类的头文件，类就具备了分类的能力。
#import “主类类名 + 分类类名.h”
1.4注意：
分类中，不可以定义实例变量，自然也不可以定义属性。
在分类中，是可以访问主类的实例变量，也可以访问主类的属性。
分类不但可以给自定义的类添加能力，还可以给系统的类添加能力。

2.扩展（Extend）：
 可以添加一个私有的能力。
扩展没有名字，扩展只可以在.m文件中使用。
在扩展中，是可以声明实例变量的，自然也可以声明属性。
在一个类中可以有多个扩展。

3.协议：
3.1优缺点：
优点：可以增强一个类的能力。
缺点：类的本质要发生改变。
3.2协议的语法：
协议的定义也是保存在文件中。
语法格式：
@protecal 协议名 <父协议>
- (void)method;
@end
给一个类添加协议（类遵守协议）
@interface类：父类<协议>
 注：如果一个类遵守一个协议，要实现协议中要求的属性或方法。
3.3 使用协议：
 id <协议> obj = 遵守协议的对象；
[obj 协议要求属性 / 方法];
3.4 注意：
在协议中声明属性 / 方法是可以使用@required或@optional关键字修饰，如果使用@required或默认修饰的属性或必须，在遵守协议的类中必须实现。
optional关键修饰的属性 / 方法，可选实现的。
3.5 协议也可以继承
协议的继承相当于协议的合并。
@protocal 子协议 <父协议>
3.6 一个类也可以遵守多个协议
@interface类：父类<协议1，协议2>
id <协议1，协议2> p = [ ... ];