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

1.多态：一个对象多种形态

实现多态必须满足三个条件

1、必须要有继承关系

2、子类要重写父类的方法

3、父类指针指向子类对象

当使用父类指针指向子类对象的时候，那么同这个这个指针调用方法就是它实际指向的这个对象的方法

多态优点：

1、让代码更加灵活

2、可以提高代码的可维护性

3、可以提高代码的复用

/****** 面向对象的原则 ******/

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

#import <Foundation/Foundation.h>

//导入动物的头文件
#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 <Foundation/Foundation.h>
#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 <Foundation/Foundation.h>
#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 <Foundation/Foundation.h>

@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、依赖关系与关联关系的区别

依赖关系是一种短期的依赖，当方法执行完毕这种依赖就不存在了

关联关系式一种长期依赖，只要对象存在那么这种依赖关系都是存在的

关联关系的耦合度高于依赖关系

耦合度：一个类的修改对另外一个类的影响程度