oc语言学习之基础知识点介绍（三）：类方法、封装以及继承的介绍

一、类方法的使用

/*
 像我们之前学的方法，必须先实例化这个类的对象才能调用这个方法，类方法不用实例化对象，直接调用这个方法。

之前学的方法调用的语法：
        [对象名  方法名];  //对象方法

类方法：
        [类名  方法名];   //类方法
 
定义：
        语法：+(返回值类型)方法名:参数列表;

注意：
        1.类方法不能直接访问成员变量。
        2.类方法里面可以调用其他的类方法，但不能直接调用对象方法。
        3.对象方法里面可以调用类方法。
        4.类方法可以和对象方法同名，互不影响。因为类方法用类名调用，对象方法用对象名调用。
        5.类方法和实例方法一样在@interface里声明,在@implementation里实现。
        6.类方法只能由类名来调用，不能用对象来调用。对象方法只能由对象调用，不能用类名调用.
        7.两个类方法之间不要直接相互调用否则死循环。
*/

#import <Foundation/Foundation.h>
@interface Test1: NSObject
/**
 *对象方法
 */
-(void)NSLog1:(NSString *) str;
/**
 *类方法
 */
+(void)NSLog1:(NSString *) str;
@end

@implementation Test1

-(void)NSLog1:(NSString  *)str{
    //返回str的值
    return str;
}

+(void)NSLog1:(NSString  *)str{
    //返回str的值
    return str;
}

@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
//        Test1*clt = [Test1new];
//        
//        NSString *str= [clt addNum1:@"哈哈哈";
//        
//        NSLog(@"str=%@",str);
        
         NSString *str= [clt addNum1:@"哈哈哈";
        
        NSLog(@"str=%@",str);
    }
    return 0;
}

二、匿名对象

/*
    匿名对象：
            就是没有任何的指针指向的对象就叫匿名对象 。
    匿名对象的缺点：
            只能用一次 。
    优点：
        方便作为参数传递。 
*/
#import <Foundation/Foundation.h>
@interface Person : NSObject{
    @public
    NSString *_name;
    int _age;
}
-(void)sayHi;
@end

@implementation Person
-(void)sayHi{
    NSLog(@"你好，我叫%@  今年%d岁",_name,_age);
}
@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
//        Person *p =[Person new];//这个并不是匿名对象
//        p->_name = @"哈哈";
//        [p sayHi];
//        [Person new];//这个就是匿名对象
        
        [Person new]->_age =16; //这是匿名对象的成员赋值
        [Person new]->_name = @"周帅帅"; //这是匿名对象的成员赋值
        [[Person new] sayHi]; //这是匿名对象调用方法    
    }
    return 0;
}

三、封装

/*
 封装实现步骤：
        1.@public去掉，默认是@protected。
        2.写一个方法用来给属性赋值的，还要写一个方法用来给属性取值。
        3.在赋值方法里面做过滤。
        4.使用的时候直接调用方法就可以了。

 封装的好处：
        可以控制是否只读，或者只写。
        只封装读的方法，那么就是只读，如果只封装赋值，那么就是只写。
        如果两个都封装就是可读可写。

 setter:赋值器：
    其实就是你封装的给某个属性赋值的方法,就叫setter方法。
        例：-(void)setName:(NSString *)name; //这就是一个setter方法
    规范：
        1.方法名以set开头，后面接不要_的属性名，并且首字母大写
        2.必须有参数，参数的类型跟你要封装的属性类型一致，形参名字可以随便取，但是一般的做法都是不要下划线的属性。
        3.返回值一定是void。
        4.形参名不能和成员变量名(属性名)一样(苹果官方推荐成员变量名前加_以示区分)。
            所以之前为什么要给属性名加_呢？就是为了和setter方法的形参名区分开来。
 
 getter:取值器
    其实就是你封装的给某个属性取值的方法，就叫getter方法。
        例：-(NSString *)name; //这就是一个getter方法。
    规范：
        1.方法名就是去掉下划线的属性名。
        2.必须有返回值，并且返回值类型与要封装的属性类型一致。
        3.没有参数。
*/
@interface Person : NSObject{
    NSString *_name;
    int _age;
    BOOL _gender;
}

/**
 *  给name赋值的方法
 *  需要一个参数，因为你要给我传值，我才能对属性赋值
 *  但是参数什么类型呢？根据你要赋值的属性的类型确定
 *  比如说要给_name赋值，那么很明显就需要传入一个跟_name同类型的数据
 */
-(void)setName:(NSString *)name;

/**
 *  取_name值的方法
 *  需要一个返回值，因为你需要把值交给别人取值，所以就需要返回值了
 *  但是返回值类型呢？那肯定是跟你需要取值的属性的类型一致
 */

-(NSString *)name;
/**
 *  给_age赋值的方法
 */
-(void)setAge:(int)age;
/**
 *  给_age取值的方法
 */
-(int)age;
-(BOOL)gender;
@end

@implementation Person

-(BOOL)gender{
    return  _gender;
}

-(void)setName:(NSString *)name{
    if([name isEqualTo:@"你麻痹"]){
        _name = @"无名氏";
    }else{
        //给属性赋值为你传进来的参数
        _name = name;
    }
}

-(NSString *)name{
    //返回这个属性
    return _name;
}

/**
 *  千万要记得，age是传进来的形参名,_age才是属性
 */
-(void)setAge:(int)age{
    if(age<0 || age>120){
        //如果传进来的值不合法，就给_age属性赋值为默认的16
        _age = 16;
    }else{
        //如果合法，我就用你传进来的值
        _age = age;
    }
}

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


/*   
重载：就是允许方法同名，但是参数不同。
oc中的方法 没有重载这个概念。

oc中 : 也是方法名的一部分。
*/


/*
oc中 static 关键字：
        1.修饰局部变量，把这个局部变量变为静态变量。 静态变量程序一启动就加载，程序退出才会回收。
 
        2.修饰全局变量，代表这个全局变量只能在本模块中访问。
 
        3.修饰函数，代表这个函数只能在本模块中调用。

        4.不能修饰成员变量（属性）
 
        5.不能修饰方法
*/

四、继承

/*
 
 继承：简单来说，就是一个类B能够拥有类A的全部属性和方法，并且还有自己一些独有的属性或者方法，这可以称之为继承
        类B继承自类A 

        在定义类的时候 在后面写一个 : 类名 
        例如：
                @interface Person : NSObject{
 
                }
                @end
    类方法调用：
            [类名 方法名];
 再次注意：OC中类B继承自类A，那么类B会拥有类A的所有属性和方法
 
 再次强调继承的语法：
                在声明类的时候在类名后面 加一个 : 然后写一个 要继承的类名
 
 继承虽然说语法上允许你继承自任何类
 
            但是，一定要符合客观事实（基本要符合 is a原则）
            student is a person
            某个类一定要属于某个类
            比如说：学生是个人 
        注意：以下语法上完全没问题，但是不符合现实，强烈不允许这样做
            @interface Dog : Person
 
            @end
 
            比如说：狗不能继承自人类，因为狗不是人
 
            @interface Dog : Animal
 
            @end
 
            这样就可以，因为狗是动物
 
 父类：被继承的那个类就叫父类。
 
 子类：继承的那个类就叫子类。
 
 基类：父类也叫基类，只不过很多书以及很多说法，说基类就是NSObject。
       以后说基类，一般就指NSObject。
 
 根类：NSObject
  
   继承的特点：
            1.子类可以拥有父类所有的属性和方法（包括父类私有的）。
            2.如果有一个子类B继承自己类A，然后类B又有一个子类C，那么这个子类C也会有类A的所有属性和方法；类具有传递性。
            3.类不可以继承自多个类！类的单根性：就是只能有一个根。
            4.一个类能被多个类继承。例如：Person可以被student继承，也可以被teacher继承。
            5.类的继承要合理：引用一句话：“人是人他妈生的，妖是妖他妈生的”。
*/

#import <Foundation/Foundation.h>

@interface Person : NSObject{
    
    @public
    NSString *_name;
    int _age;
}

-(void)sayHi;

@end

@implementation Person

-(void)sayHi{
    
    NSLog(@"hello,eat no?");
}

@end

@interface Student : Person

@end

@implementation Student

@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {        
        Person *p = [Person new];        
        [p sayHi];        
        [Person alloc];        
        Student *s = [Student new];        
        s->_name = @"刘晓晓";        
        NSLog(@"%@",s->_name);        
        [s sayHi];        
    }
    return 0;
}