黑马程序员 5 oc三大特性

------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -----

又是奋斗的一天，继续上次话题！！！

本期目录：

1.错误与解决

2.oc三大特性深究

3.其他

4.个人总结

一：错误与解决

1.记住一个经典的错误：unrecognizedselector sent to instance 错误原因：给对象发送的消息无法调用，也就是说没有那个方法

2.死循环了。学习了类方法和对象方法后，稍不留意就会产生死循环。比如：在类方法中又调用了类方法或者在对象方法中又调用了对象方法

3.self和super的纠结！！！记住：self就是正在使用的本对象，super是父类的指针

4.又出现了oc字符串没有加@

5.NSString 是oc特有的字符串处理类，是一个标准的类，可以有很多方法可以调用。

6.尽量不要再使用new来创建对象，开始使用 alloc 和init。

7.isa指向当前类型是什么就指向什么类

8.声明的方法名千万别错了。

9.xcode控制台的显示问题。

二.oc三大特性

继续oc三大特性，以实验代码为主

封装

第一个封装实验：

//
//  main.m
//  aa
//
//  Created by 赵海伟 on 14/11/22.
//  Copyright (c) 2014年 赵海伟. All rights reserved.
//

#import <Foundation/Foundation.h>

@interface Student : NSObject
{
    int age;//不要设为@public
    
    int no;
}

- (void)setAge:(int)newAge;//age的set方法
- (int)age;

- (int)no;//no 只需要get方法
- (void)study;



@end

@implementation Student
    - (void)setAge:(int)newAge
    {

    //参数入口判断，保证age永远>0
    if(newAge <= 0)
    {
        newAge = 1;
        
    }
        age = newAge;
    }
    
    - (int)age
    {
        return age;
    }
    
    - (int)no
    {
        return no;
    }
    
    - (void)study
    {
        NSLog(@"%d岁的学生在学习",age);
    }
    
    @end
    
    
    int main()
    {
        Student *stu = [Student new];
        
        [stu setAge:10];
        
        NSLog(@"学生的年龄是%d",[stu age]);
        return 0;
        
    }

xcode结果：

总结:可以看到，我们避开了直接访问成员变量，而是十分有效安全的调用了创业成员变量的set和get。更像面向对象的思想。

再次记录：

set方法

 1.作用： 提供一个方法给外界设置成员变量值，可以在方法里面对参数进行相应过滤

 2.命名规范：

 1> 方法名必须以set开头

 2> set后面跟上成员变量的名称，成员变量的首字母必须大写

 3> 返回值一定是void

 4> 一定要接收一个参数，而且参数类型跟成员变量类型一致

 5> 形参的名称不能跟成员变量名一样

get方法

 1.作用：返回对象内部的成员变量

 2.命名规范：

 1> 肯定有返回值，返回值类型肯定与成员变量类型一致

 2> 方法名跟成员变量名一样

 3> 不需要接收任何参数

第二个封装实验：（片段）

<span style="font-size:18px;">// sex的set和get方法
- (void)setSex:(Sex)sex;
- (Sex)sex;

// no的set和get方法
- (void)setNo:(int)no;
- (int)no;

@end

@implementation Student

- (void)setSex:(Sex)sex
{
    _sex = sex;
}

- (Sex)sex
{
    return _sex;
}

- (void)setNo:(int)no
{
    _no = no;
}
- (int)no
{
    return _no;
}
</span>

总结：可以看到，这里的代码块，成员变量加_，这是推荐的做法。

所以：成员变量的命名规范：一定要以下划线 _ 开头

作用：1.让成员变量和get方法的名称区分开

2.可以跟局部变量区分开，一看到下划线开头的变量，一般都是成员变量

第三个封装实验

/*
 4.设计一个成绩类
 * C语言成绩（可读可写）
 * OC成绩（可读可写）
 * 总分（只读）
 * 平均分（只读）
*/
#import <Foundation/Foundation.h>

@interface Score : NSObject
{
    int _cScore; // C语言成绩
    int _ocScore; // OC成绩
    
    int _totalScore;// 总分
    int _averageScoe; // 平均分
}
//注意这里没有totalscore和averageScore的set方法，因为，这两个成员变量取决于cscore和ocscore。
- (void)setCScore:(int)cScore;
- (int)cScore;

- (void)setOcScore:(int)ocScore;
- (int)ocScore;

- (int)totalScore;
- (int)averageScore;

@end

@implementation Score
- (void)setCScore:(int)cScore
{
    _cScore = cScore;
    
    // 计算总分
    _totalScore = _cScore + _ocScore;
    _averageScoe = _totalScore/2;
}
- (int)cScore
{
    return _cScore;
}

- (void)setOcScore:(int)ocScore
{
    _ocScore = ocScore;
    
    // 计算总分
    _totalScore = _cScore + _ocScore;
    _averageScoe = _totalScore/2;
}
// 监听成员变量的改变

- (int)ocScore
{
    return _ocScore;
}

- (int)totalScore
{
    return _totalScore;
}
- (int)averageScore
{
    return _averageScoe;
}
@end


int main()
{
    Score *s = [Score new];
    
    [s setCScore:90];
    [s setOcScore:100];
    
    [s setCScore:80];
    
    
    int a = [s totalScore];
    
    NSLog(@"总分：%d", a);
    
    return 0;
}

总结：上面的代码告诉我：像totalscore和averagescore这样的成员变量，并没有set方法，因为他们不是设置的，而是由其他成员变量得来。举个例子：如果我们在main方法中连续调用了setTotalScore方法，那么就会让tatalscore连续加2次。我的感觉是set方法和get方法中尽量少有逻辑代码。

继承

理解了封装后，感觉有点入门了，所以继承也不难，理清继承关系。

<span style="font-size:18px;">#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;
}</span>

多态

<span style="font-size:18px;">#import <Foundation/Foundation.h>



// 动物
@interface Animal : NSObject
- (void)eat;
@end

@implementation Animal
- (void)eat
{
    NSLog(@"Animal-吃东西----");
}
@end

// 狗
@interface Dog : Animal
- (void)run;
@end

@implementation  Dog
- (void)run
{
    NSLog(@"Dog---跑起来");
}
- (void)eat
{
    NSLog(@"Dog-吃东西----");
}
@end

// 猫
@interface Cat : Animal

@end

@implementation Cat
- (void)eat
{
    NSLog(@"Cat-吃东西----");
}
@end


// 如果参数中使用的是父类类型，可以传入父类、子类对象
void feed(Animal *a)
{
    [a eat];
}

int main()
{
    //我们可以看见dog对象竟然可以背cat类指针调用
     
     // 多态：父类指针指向子类对象
     Animal *a = [Dog new];
    Cat *b = [Dog new];
    
     
     // 调用方法时会检测对象的真实形象
    [a eat];
    [b eat];
    
    return 0;
}</span>

总结：多态

 1.没有继承就没有多态

 2.代码的体现：父类类型的指针指向子类对象

 3.好处：如果函数\方法参数中使用的是父类类型，可以传入父类、子类对象

4.局限性：

 1> 父类类型的变量 不能 直接调用子类特有的方法。必须强转为子类类型变量后，才能直接调用子类特有的方法

所以上面的方法调用中，dog类对象可以被cat指针指向，并安全调用。来自于oc弱语法！！！

3.其他

oc弱语法：

oc本质上是面向过程的，他的类用strut实现。他的编译器有容错能力很强，经常出现“模棱两可”的语法。比如：上面的cat指针指向dog对象。

self关键字：

/*
 设计一个计算器类
 * 求和
 * 求平均值
 */

#import <Foundation/Foundation.h>

// 工具类：基本没有任何成员变量，里面的方法基本都是类方法
@interface JiSusnQi : NSObject
+ (int)sumOfNum1:(int)num1 andNum2:(int)num2;

+ (int)averageOfNum1:(int)num1 andNum2:(int)num2;
@end

@implementation JiSusnQi
+ (int)sumOfNum1:(int)num1 andNum2:(int)num2
{
    return num1 + num2;
}

+ (int)averageOfNum1:(int)num1 andNum2:(int)num2
{
    // 在这种情况下，self代表类
    int sum = [self sumOfNum1:num1 andNum2:num2];
    return sum / 2;
}
@end

int main()
{
    int a = [JiSusnQi averageOfNum1:10 andNum2:12];
    
    NSLog(@"a=%d", a);
    
//    JiSusnQi *jsq = [JiSusnQi new];
//    
//    
//    [jsq sumOfNum1:10 andNum2:13];
    
    return 0;
}

self总结：

 1> 谁调用了当前方法，self就代表谁
 self出现在对象方法中，self就代表对象
  self出现在类方法中，self就代表类
 2> 在对象方法利用"self->成员变量名"访问当前对象内部的成员变量

super关键字

super的作用
 1.直接调用父类中的某个方法
 2.super处在对象方法中，那么就会调用父类的对象方法
   super处在类方法中，那么就会调用父类的类方法
 3.使用场合：子类重写父类的方法时想保留父类的一些行为

4个人总结

1 认真看了视频中的代码，理解了oc中的继承，多态，封装的特性。与java比较，个人感觉：java语法更加规范。继承和多态在java中很关键。oc中多少不是特别彻底。

2 分清继承和组合的区别。继承 = is，组合 = has.

3.和同伴交流心得。

4.要多写多练

黑马就在眼前！！！

------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------