ios学习之旅--多态与点语法

1.多态：一个对象多种形态
   实现多态必须满足三个条件
   1、必须要有继承关系
   2、子类要重写父类的方法
   3、父类指针指向子类对象 
   当使用父类指针指向子类对象的时候，那么同这个这个指针调用方法就是它实际指向的这个对象的方法
     
多态优点：
     1、让代码更加灵活
     2、可以提高代码的可维护性
     3、可以提高代码的复用
   
    /****** 面向对象的原则 ******/

    // 依赖于抽象不要依赖具体

#import 

//导入动物的头文件
#import "CZAnimal.h"
#import "CZDog.h"
#import "CZCat.h"
#import "CZManager.h"
#import "CZTiger.h"

int main(int argc, const char * argv[]) {
   
    CZAnimal *animal = [CZDog new];

//  如果你要使用子类对象中的特有方法（只有子类中有父类中没有的方法）
//  需要把父类对象强转位子类对象
//  但是这个时候你必须保证这个指针确实是指向这个子类对象
    [(CZDog *)animal bark];   
    CZAnimal *ani = [CZAnimal new];
//  千万不要把一个指向父类对象的指针强转为子类对象
    CZDog *dog = (CZDog *)ani;   
//    [dog bark];//此处报经典的方法没有找到的错误的    
    
    return 0;
}

void test1()
{
    // 多态    
    CZAnimal *animal = [CZDog new];
    //
    [animal eat];
    //  让父类指针指向CZCat对象
    animal = [CZCat new];    
    [animal eat];    
    /**  以下是多态使用场景         ****/
    //   创建一个管理员
    CZManager *manager = [CZManager new];   
    CZCat * cat  = [CZCat new];
    //  管理员喂猫
    [manager feedAnimal:cat];    
    CZDog *dog = [CZDog new];
    [manager feedAnimal:dog] ;     
    CZTiger *tiger  = [CZTiger new];
    [manager feedAnimal:tiger];    
}
void test()
{
    CZAnimal *animal = [CZAnimal new];
    
    [animal eat];
    // 创建一个狗
    CZDog *dog =  [CZDog new];
    
    [dog bark];
    //  狗吃
    [dog eat];
    //   创建一只猫
    CZCat *cat  = [CZCat new];
    [cat eat];
}
#import "CZPerson.h"
@interface CZAnimal :NSObject
{
    int _age;//年龄
}
/**
 *  吃
 */
-(void) eat;

@end

#import "CZAnimal.h"

@implementation CZAnimal
/**
 *  吃
 */
-(void) eat
{
    NSLog(@"CZAnimal 吃");
}
@end

#import "CZAnimal.h"

@interface CZCat : CZAnimal

@end

#import "CZCat.h"

@implementation CZCat

/**
 *  重写Animal的吃的方法
 */

-(void) eat
{
    NSLog(@"CZCat 吃");
}

@end


#import "CZAnimal.h"

@interface CZDog : CZAnimal

/**
 * 叫
 */
- (void) bark;

@end

#import "CZDog.h"

@implementation CZDog

/**
 * 叫
 */
- (void) bark
{
    NSLog(@"CZDog 叫");
}
//子类要重写父类的方法
-(void)eat
{
    NSLog(@"CZDog 吃");
}

@end

#import 
#import "CZAnimal.h"
#import "CZCat.h"
#import "CZDog.h"

@interface CZManager : NSObject
//喂动物
-(void) feedAnimal:(CZAnimal *) animal;

@end

#import "CZManager.h"
//动物园的管理员
@implementation CZManager
-(void) feedAnimal:(CZAnimal *) animal
{
    NSLog(@"喂动物");
    [animal eat];
}

@end


#import "CZAnimal.h"

@interface CZTiger : CZAnimal

@end

#import "CZTiger.h"

@implementation CZTiger

- (void) eat
{
    NSLog(@"CZTiger 吃");
}

2.点语法
     通过.号形式访问getter 和 setter方法
   
 注意点：


    1、点语法实质就是调用getter 和setter 方法
    2、它不是直接访问成员变量   
点语法优点：简化编程，点语法会显得更加简洁

#import 
#import "CZPerson.h"

int main(int argc, const char * argv[]) {
 
    CZPerson *person = [CZPerson new];
       
    person.age = 20;
//  当点语法用在=的左边就是调用setter方法
//    [person setAge:20];
//当点语法用在=的右边就是调用getter方法
    int age = person.age;
    [person age];
    NSLog(@"%d",age);
    
    return 0;
}


#import 

@interface CZPerson : NSObject
{
    int _age;//年龄
    NSString * _name;//姓名
}

- (void) setAge:(int) age;

- (int) age;

- (void) setName:(NSString *) name;

- (NSString *) name;


@end

#import "CZPerson.h"

@implementation CZPerson

- (void) setAge:(int) age
{
    NSLog(@"setAge:");
    
//  这里是通过self调用setAge方法，此处就会出现死循环
//  一定不要再setter方法中使用点语法给成员变量赋值
//    self.age = age;
    
    _age = age;
}

- (int) age
{
    NSLog(@"age");
    
//  一定不要再getter方法中使用点语法返回成员变量的值，因为会出现死循环
    return self.age;
//    return _age;
}

- (void) setName:(NSString *) name
{
    _name = name;
}

- (NSString *) name
{
    return _name;
}

@end

3.知识点回顾：
 1、类方法
     1、声明定义以+开头
     2、类方法隶属类的，只能通过类来调用
     3、不可以直接访问成员变量
     4、不可以直接调用对象方法
     5、类可以调用其他类方法
  2、对象方法
     1、声明或定义的时候，以-开头
     2、对象方法隶属于对象的，只能同过对象调用
     3、可以直接访问成员变量
     4、可以直接调用其他对象方法
     5、可以调用类方法
 
 注意点：
    类方法和对象方法可以重名的
 
  2、匿名对象：没有名字对象
     1、当我们不需要重复使用这个对象的时候，就使用匿名对象，因比较简洁
     场景：1、创建一个对象后仅仅调用一次某个方法
          2、作为函数或方法的实参
     2、缺点：创建出来对象仅能使用一次
 
 3、封装
    1、类是属于与功能封装
    2、数据的封装：不让外界直接访问成员变量，而是提供getter 和 setter 供外界调用
    3、提高成员健壮性
       提高代码的灵活性
      提高程序的可维护性
    如何进行封装
      1、为每一个成员变量提供getter 和 setter 方法
      2、setter 方法，写方法,给成员变量赋值
        1、必须是对象方法，必须以- 开头
        2、必须没有返回值
        3、方法名必须以set + 成员变量名称去掉下划线首字母大写
        4、必须有一个形参，并且参数类与成员变量类型一致
      3、getter 方法，读方法，读取成员变量的值
        1、必须是对象方法，必须以- 开头
        2、必须要一个返回值，并且返回值的类型与成员变量类型一致
        3、方法名就是成员变量去掉下划线
        4、必须空参的
 4、类与类关系
    1、依赖关系
       当A类的对象作为B的方法中的形参或局部变量,B依赖于A,B和A之间就存一种依赖关系
    2、关联关系，HasA关系，当B类中有一个成员变量是A类的对象，那么我们说B类拥有一个A类对象，A 与 B之间的关系为关联关系
       1、当B中很多地方都使用A类对象，那么这时候我们A类对象作为B类成员变量
    3、依赖关系与关联关系的区别
       依赖关系是一种短期的依赖，当方法执行完毕这种依赖就不存在了
       关联关系式一种长期依赖，只要对象存在那么这种依赖关系都是存在的
       关联关系的耦合度高于依赖关系
       耦合度：一个类的修改对另外一个类的影响程度