Objective

@property(assign) int age;//assign  基本数据类型

@property(copy) NSString *name;//copy    字符串

@property(nonatomic,retain) Father *father;//多线程访问不安全，但效率高     Father（类）

@property(atomic,retain) Father *father2;//多线程访问安全      Father（类）

在 .m 文件中使用 @synthesize 编译器指令   

@synthesize age;

 

@synthesize name;

@synthesize father;

@synthesize father2;

在编译过程中，系统会自己添加相当于（java的set和get方法）

协议与委托
     一、先创建一个协议，在协议写方法
     二、创建一个委托者的类，在类名后面写<协议名>，然后在此类的实现中重写协议的方法
     三、创建一个雇主类，在雇主类中写委托者的方法，在实现中实现方法，方法写的是委托者自己回调自己的方法。
     四、在main函数中创建雇主类和委托者类的对象，雇主把协议给委托者，最后雇主调用委托者的方法。
    下面有个实例：
    1、协议（teachdelegate.h）
    #import
    @protocol teachdelegate
    -(void)teachIos:(int)num;//协议中的方法
    @end
    2、委托类
    工人类（ Worker.h）
    #import
    #import "teachdelegate.h"
    @interface Worker : NSObject
    @end
    
    工人类的实现(Worker.m)
    #import "Worker.h"
    @implementation Worker
    //重写协议中的方法
    -(void)teachIos:(int)num{
        NSLog(@"教%d个学生",num);
    }
    @end
    
    3、雇主
    老板类（Boss.h）
    #import
    #import "teachdelegate.h"
    @interface Boss : NSObject
    @property(retain,nonatomic) id delegate;
    -(void)teachStudentIos;//工人的方法
    @end
    
    老板类的实现(Boss.m)
    #import "Boss.h"
    @implementation Boss
    @synthesize delegate;
    -(void)teachStudentIos
    {
        [delegate teachIos:26];//工人调用自己的方法
    }
    @end
    4、main方法
    Boss *boss=[[Boss alloc]init];//创建雇主(Boss)对象
    Worker *worker=[[Worker alloc]init];//创建委托者(Worker)对象
    boss.delegate=worker;//雇主(Boss)把协议给委托者(Worker)
    [boss teachStudentIos];//雇主调用工人的方法

内存管理
    一:引用计数器：标识对象当前被引用的次数。
    (1)当使用alloc、new方法或者通过copy消息创建一个对象时，对象的引用计数器被设置为1，当调用retain方法时，引用计数器+1，调用release方法时 ，引用计数器-1 ，当计数器值为0时，系统会自动释放内存，调用retaincount可以获得当前对象的引用次数
    (2)内存中的常量字符串的空间分配与其它对象不同,它们没有引用计数机制
     //字符串无引用计数器
    NSString *str=[[NSString alloc]init];
    二、自动释放池(autoreleasepool)
    总结的三个经验
    1、只要有alloc ,init 创建的对象首先想到要在一个合适的地方释放（该对象使用完了，不需要了的地方
     2、alloc的对象，找不到合适的地方释放，这个时候考虑，加入自动释放池（autorelease）
    3 系统类方法产生的对象不需要考虑释放问题。
    
    (1)手动释放（只要有alloc ,init 创建的对象首先想到要在一个合适的地方释放）
    NSNumber *num=[[NSNumber alloc]init];//count=1
    [num retain];//count=2
    NSLog(@"num retaincount==%d",(unsigned)[num retainCount]);
    [num retain];//count=3
    NSLog(@"num retaincount==%d",(unsigned)[num retainCount]);
    [num release];//count=2
    NSLog(@"num retaincount==%d",(unsigned)[num retainCount]);
    [num release];//count=1
    NSLog(@"num retaincount==%d",(unsigned)[num retainCount]);
    (2)创建自动释放池
    NSAutoreleasePool *pool=[[NSAutoreleasePool alloc]init];
    //alloc的对象，找不到合适的地方释放
    NSObject *obj=[[[NSObject alloc]init]autorelease];//autorelease(自动加入释放池)
    NSLog(@"obj retaincount==%d",(unsigned)[obj retainCount]);//retaincount＝1
    //系统类方法产生的对象不需要考虑释放问题。
    NSMutableArray *arrays=[NSMutableArray array];
    
    [pool drain];//凡是被添加到自动释放池的对象都会在[pool drain]时对其中的每个对象引用计数减1,若对象的引用计数为0则回收资源所占资。

单例模式（singleton）,又叫单肽模式:确保一个类中只有一个实例，

并且自行实例化以及向整个系统提供这个实例。

一、单例模式的优点：

    1、实例控制:singleton会阻止其他对象实例化自己的singleton对象

    的副本，从而确保所以对象都访问唯一的实例。

    2、灵活性:因为类控制了实例化过程，所以类可以更新灵活的修改实例化过程。

    

二、创建单列模式的步骤:(以类singleton为例)

    1、先创建一个静态的实例对象并初始化

    2、创建一个实例化方法，判断实例对象是否为nil，如果为nil则创建对象并返回，否则返回nil

    3、重写 +(id)allocWithZone:(NSZone *)zone;

    4、重写 +(id)copyWithZone:(NSZone *)zone;

    

    singleton.h中

    #import

    @interface Singleton : NSObject

    

    @property(assign) int age;

    

    +(Singleton *)shareInstance;//实例化方法

    

    +(id)allocWithZone:(NSZone *)zone;//重写

    

    +(id)copyWithZone:(NSZone *)zone；//重写

    

    -(void)show;

    @end

    

    singleton.m中

    #import "Singleton.h"

    static Singleton *instance=nil;//创建一个静态的实例对象并初始化

    @implementation Singleton

    @synthesize age;

    //实例化方法实现

    +(Singleton *)shareInstance{

        @synchronized(self){

            if(nil==instance)

            {

                instance=[[self alloc]init];

            }

        }

        return instance;

    }

    //重写

    +(id)allocWithZone:(NSZone *)zone

    {

        @synchronized(self){

            if(nil==instance)

            {

                instance=[super allocWithZone:zone];

                return instance;

            }

        }

        return nil;

    }

    //重写

    +(id)copyWithZone:(NSZone *)zone{

        return self;

    }

    

    

    -(void)show{

        age++;

        NSLog(@"%d",age);

    }

    @end

三、验证单例模式的对象（实例）共享

    在类singleton.m中写了个方法

    -(void)show{

        age++;

        NSLog(@"%d",age);

    }

    

    在main方法中验证

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

    {

        

        @autoreleasepool {

            //验证单例模式

            Singleton *sington=[Singleton shareInstance];

            if(nil!=sington)

            {

                NSLog(@"not nil***********");

            }

            //验证对象共享性

            Singleton *sington2=[Singleton shareInstance];

            sington.age=20;

            [sington show];//输出为21

            [sington2 show];//输出为22

            //对象共享性：也就是两个不同的对象singleton和singleton2共享单例模式的同一个变量age

            

        }

        return 0;

    ｝