05-面向对象语法04

标签：

一、 继承

1. 继承的基本用法

l 设计两个类Bird、Dog

// Bird的声明

@interface Bird : NSObject

{

    @public

    int weight;

}

- (void)eat;

@end

// Bird的定义

@implementation Bird

- (void)eat {

    NSLog(@"吃吃吃-体重：%d", weight);

}

@end

// Dog的声明

@interface Dog : NSObject

{

    @public

    int weight;

}

- (void)eat;

@end

// Dog的定义

@implementation Dog

- (void)eat {

    NSLog(@"吃吃吃-体重：%d", weight);

}

@end

// Animal的声明

@interface Animal : NSObject

{

    @public

    int weight;

}

- (void)eat;

@end

// Animal的定义

@implementation Animal

- (void)eat {

    NSLog(@"吃吃吃-体重：%d", weight);

}

@end

l 子类在父类的基础上拓充属性和方法

// Bird的声明

@interface Bird : Animal

{

    @public

    int height;

}

- (void)fly;

@end

// Bird的定义

@implementation Bird

- (void)fly {

        NSLog(@"飞飞飞-高度：%d", height);

}

@end

// Dog的声明

@interface Dog : Animal

{

    @public

    int speed;

}

- (void)run;

@end

// Dog的定义

@implementation Dog

- (void)run {

        NSLog(@"跑跑跑-高度：%d", speed);

}

@end

l 父类被继承了还是能照常使用的

l 父类的静态方法

l 画继承结构图，从子类抽取到父类

l NSObject的引出：全部OC类的最终父类，包含了一些常用方法，比如+new

2. 继承的专业术语

l 父类\超类  superclass

l 子类  subclass\subclasses

3. 继承的好处

l 不改变原来模型的基础上，拓充方法

l 建立了类与类之间的联系

l 抽取了公共代码

l 坏处：耦合性强

#import <Foundation/Foundation.h>

/*

1.继承的好处：

1> 抽取重复代码

2> 建立了类之间的关系

3> 子类可以拥有父类中的所有成员变量和方法

2.注意点

1> 基本上所有类的根类是NSObject

*/

/********Animal的声明*******/

@interface Animal : NSObject

{

int _age;

double _weight;

}

- (void)setAge:(int)age;

- (int)age;

- (void)setWeight:(double)weight;

- (double)weight;

@end

/********Animal的实现*******/

@implementation Animal

- (void)setAge:(int)age

{

    _age = age;

}

- (int)age

{

return _age;

}

- (void)setWeight:(double)weight

{

    _weight = weight;

}

- (double)weight

{

return _weight;

}

@end

/********Dog*******/

// : Animal 继承了Animal，相当于拥有了Animal里面的所有成员变量和方法

// Animal称为Dog的父类

// Dog称为Animal的子类

@interface Dog : Animal

@end

@implementation Dog

@end

/********Cat*******/

@interface Cat : Animal

@end

@implementation Cat

@end

int main()

{

    Dog *d = [Dog new];

    [d setAge:10];

    NSLog(@"age=%d", [d age]);

    return 0;

}

4. 继承的细节

l 单继承

l 子类和父类不能有相同的成员变量

l 方法的重写

/*

1.重写：子类重新实现父类中的某个方法，覆盖父类以前的做法

2.注意

1> 父类必须声明在子类的前面

2> 子类不能拥有和父类相同的成员变量

3> 调用某个方法时，优先去当前类中找，如果找不到，去父类中找

2.坏处：耦合性太强

*/

#import <Foundation/Foundation.h>

// Person

@interface Person : NSObject

{
    
    int _age;

}

- (void)setAge:(int)age;

- (int)age;

- (void)run;

+ (void)test;

@end

@implementation Person

+ (void)test

{

    NSLog(@"Person+test");

}

- (void)run

{

    NSLog(@"person---跑");

}

- (void)setAge:(int)age

{

    _age = age;

}

- (int)age

{

    return _age;

}

@end

// Student

@interface Student : Person

{

    int _no;

// int _age;

}

+ (void)test2;

@end

@implementation Student

// 重写：子类重新实现父类中的某个方法，覆盖父类以前的做法

- (void)run

{

    NSLog(@"student---跑");

}

+ (void)test2

{

    [self test];

}

@end

int main()

{

    [Student test2];

//    Student *s = [Student new];

//    

//    [s run];

    return 0;

}

5. 继承的使用场合

l 它的所有属性都是你想要的，一般就继承

l 它的部分属性是你想要的，可以抽取出另一个父类

/*

1.继承的使用场合

1> 当两个类拥有相同属性和方法的时候，就可以将相同的东西抽取到一个父类中

2> 当A类完全拥有B类中的部分属性和方法时，可以考虑让B类继承A类

A

{

    int _age;

    int _no;

 }

{

    int _weight;

 }

 // 继承：xx 是 xxx

 // 组合：xxx 拥有 xxx

2.组合

A

 {

     int _age;

     int _no;

 }

 B

 {

     A *_a;

     int _weight;

 }

@interface Score : NSObject

{

int _cScore;

int _ocScore;

}

@end

@implementation Score

@end

@interface Student : NSObject

{

// 组合

    Score *_score;

//    int _cScore;

//    int _ocScore;

int _age;

}

@end

@implementation Student

@end

6. super关键字

l 分别调用父类的对象方法和类方法

/*

僵尸

跳跃僵尸、舞王僵尸、铁桶僵尸

 */

#import <Foundation/Foundation.h>

/*

 super的作用

 1.直接调用父类中的某个方法

 2.super处在对象方法中，那么就会调用父类的对象方法

   super处在类方法中，那么就会调用父类的类方法

 3.使用场合：子类重写父类的方法时想保留父类的一些行为

 */

// 僵尸

@interface Zoombie : NSObject

- (void)walk;

+ (void)test;

- (void)test;

@end

@implementation Zoombie

- (void)walk

{

    NSLog(@"往前挪两步******");

}

+ (void)test

{

    NSLog(@"Zoombie+test");

}

- (void)test

{

    NSLog(@"Zoombie-test");

}

@end

// 跳跃僵尸

@interface JumpZoombie : Zoombie

+ (void)haha;

- (void)haha2;

@end

@implementation JumpZoombie

+ (void)haha

{

    [super test];

}

- (void)haha2

{

    [super test];

}

- (void)walk

{

// 跳两下

    NSLog(@"跳两下");

// 走两下(直接调用父类的walk方法)

    [super walk];

//NSLog(@"往前挪两步----");

}

@end

int main()

{

//[JumpZoombie haha];

    JumpZoombie *jz = [JumpZoombie new];

    [jz haha2];

return 0;

}

二、 多态

1． 多态的基本概念

l 某一类事物的多种形态

l OC对象具有多态性

2． 多态的体现

Person *p = [Student new];

p->age = 100;

[p walk];

l 子类对象赋值给父类指针

l 父类指针访问对应的属性和方法

3． 多态的好处

l 用父类接收参数，节省代码

4． 多态的局限性

l 不能访问子类的属性（可以考虑强制转换）

5． 多态的细节

l 动态绑定：在运行时根据对象的类型确定动态调用的方法

三、 NSString的简单使用

1. 字符串的快速创建

NSStirng *str = @“Hello”;

2. 使用静态方法创建

3. 使用%@输出字符串

NSString *name = @”mj”;

NSLog(@“我的名字是%@”,  name);

05-面向对象语法04

标签：

原文地址：http://www.cnblogs.com/sundaboke/p/4515042.html