黑马程序员 《ios零基础教程》--“三大特性”-封装、继承、多态 2014-4-22总结

---------------------- <a href="http://edu.csdn.net"target="blank">ASP.Net+Unity开发</a>、<a href="http://edu.csdn.net"target="blank">.Net培训</a>、期待与您交流！ ----------------------

今天总结面向对象中的“三大特性”-封装、继承、多态，外加对类方法和self方法的使用

一、封装

1.封装的基本使用

set方法

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

 2.命名规范：

 1>方法名必须以set开头

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

 3>返回值一定是void

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

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

 get方法

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

 2.命名规范：

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

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

 3>不需要接收任何参数

#import <Foundation/Foundation.h>
@interface Student : NSObject
{
    //成员变量尽量不要用@public
    int age;
    
    //只允许外界访问我的no，不允许外界修改我的no
    int no;//只需要提供get方法
}
- (void)setAge:(int)newAge;
- (int)age;
- (void)study;

@end

#import "Student.h"
@implementation Student
//set方法的实现
- (void)setAge:(int)newAge
{
    //对传进来的参数进行过滤
    if (newAge <= 0) {
        newAge = 1;
    }
    age = newAge;   
    //这里代码一定要敲
    
//    if(age <= 0)
//    {
//        age = 1;
//    }else{
//        age = newAge;
//    }   
}
- (int)age
{
    return age;
}
- (void)study
{
    NSLog(@"%d岁的学生在学习",age);
}
@end

#import <Foundation/Foundation.h>
#import "Student.h"

int main(int argc, const char * argv[])
{
    @autoreleasepool {
        Student *stu = [Student new];
        //stu ->age = -10;        
        //stu ->age = 10;        
        [stu setAge:-10];
        [stu study];       
        NSLog(@"学生的年龄是%d岁",[stu age]);
    }
    return 0;
}

2.封装的联系

 练习：设计一个成绩类

 *C语言成绩（可读可写）

 *OC成绩（可读可写）

 *总分（只读）

 *平均分（只读）

#import <Foundation/Foundation.h>

@interface Socre : NSObject
{
    int _cScore; //C语言成绩
    int _ocScore; //OC成绩
    
    int _totalScore; //总分
    int _avarageScore; //平均分   
}

- (void)setCScore:(int)cScore;
- (int)cScore;

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

- (int)totalScore;
- (int)avarageScore;
@end


#import "Socre.h"
@implementation Socre

- (void)setCScore:(int)cScore
{
    _cScore = cScore;   
    _totalScore = _cScore + _ocScore;    
    _avarageScore = _totalScore / 2;
}

- (int)cScore
{
    return _cScore;
}

- (void)setOcScore:(int)ocScore
{
    _ocScore = ocScore;
    
    //计算总分和平均分
    //这样在C 和 OC 改变成绩时就及时计算总分和平均分，起到监听作用
    _totalScore = _cScore + _ocScore;    
    _avarageScore = _totalScore / 2;
}

- (int)OcScore
{
    return _ocScore;
}

- (int)totalScore
{
    return _totalScore;
}

- (int)avarageScore
{
    return _avarageScore;
}


@end

#import <Foundation/Foundation.h>
#import "Socre.h"

int main(int argc, const char * argv[])
{
    @autoreleasepool {
        Socre *s = [Socre new];
        
        [s setCScore:90];
        [s setOcScore:100];       
        int a = [s totalScore];
        NSLog(@"a = %d",a);        
        int b = [s avarageScore];
        NSLog(@"b = %d",b);        
    }
    return 0;
}

二、继承

1.继承的基本使用

 1>继承的好处：

  1)抽取重复代码

  2)建立了类之间的关系

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

 2>注意点

  1)基本上所有类的根类都是NSObject

#import <Foundation/Foundation.h>

@interface Animal : NSObject
{
    int _age;
    double _weight;
}

- (void)setAge:(int)age;
- (int)age;

- (void)setWeight:(double)weight;
- (double)weight;

@end
#import "Animal.h"
@implementation Animal
- (void)setAge:(int)age
{
    _age = age;
}

- (int)age
{
    return _age;
}

- (void)setWeight:(double)weight
{
    _weight = weight;
}

- (double)weight
{
    return _weight;
}

@end
#import "Animal.h"
@interface Dog : Animal
@end

#import "Dog.h"
@implementation Dog
@end

#import "Animal.h"
@interface Cat : Animal
@end

#import "Cat.h"
@implementation Cat
@end

#import <Foundation/Foundation.h>
//#import "Animal.h"
//#import "Dog.h"
#import "Cat.h"

int main(int argc, const char * argv[])
{
    @autoreleasepool {
        Cat *c = [Cat new];       
        [c setAge:10];        
        //这里不能用int a = [c setAge:10]; 这里要输出，需要调用的是get方法
        int a = [c age];       
        NSLog(@"a = %d",a);       
    }
    return 0;
}

2.继承的使用注意事项

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

 2>注意

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

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

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

 3>坏处：耦合性太强，既：如果父类消失，子类就没法使用

3.继承和组合

 1>继承的使用场合

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

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

#import <Foundation/Foundation.h>
#import "Score.h"
@interface Student : NSObject
{
    //组合
    Score *_score;
    int _cScore;
    int _ocScore;
    int _age;
}
@end

4.继承中super的作用

 super的作用

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

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

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

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

#import <Foundation/Foundation.h>

@interface Zoombie : NSObject
- (void)walk;
+ (void)test;
- (void)test;

@end

#import "Zoombie.h"

@interface JumpZoombie : Zoombie
+ (void)haha;
- (void)haha2;
//- (void)walk;
@end

#import "JumpZoombie.h"
@implementation JumpZoombie

+ (void)haha
{
    [super test];
}
- (void)haha2
{
    [super test];
}
- (void)walk
{
    //跳两下
    NSLog(@"跳两下");   
    //走两下（直接调用父类的walk方法）
    [super walk];
    //NSLog(@"往前挪两步----");
}
@end

三、多态

1.多态的基本使用

#import <Foundation/Foundation.h>
#import "Dog.h"
#import "Cat.h"

void feed(Animal *a)
{
    [a eat];
}
int main(int argc, const char * argv[])
{
    @autoreleasepool {        
//        Animal *aa = [Dog new];
        //多态的局限性：父类类型的变量 不能用来调用子类的方法
//        [aa run];
        //将aa转为Dog *类型的变量
//        Dog *dd = (Dog *)aa;
//        
//        [dd run]; 
        
        
        Animal *aa = [Animal new];
        feed(aa);
//
//        Dog *dd = [Dog new];
//        feed(dd);
//        
        //这里逻辑上更是错得离谱，：猫属于字符。但是同样语法上检测没有错误
//        NSString *s = [Cat new];
        
        //OC弱语法，这在逻辑上是错误的：动物属于猫，逻辑上错误，但是OC语法上不检测错误
//        Cat * c = [Animal new];
        
        NSObject *n = [Dog new];
        NSObject *n2 = [Animal new];
        
        //多种形态
        Dog *d = [Dog new];
        
        //多态：父类指针指向子类对象，这里是动态绑定，检测Animal的真实形象是狗
        Animal *a = [Dog new];        
        [a eat];
        }
    return 0;
}

四、类方法的基本使用

1.类方法的基本使用

 类方法：

 1>加号 +开头

 2>只能由类（名）来调用

 3>类方法中不能访问成员变量（实例变量），成员变量在对象中

 

 类方法的好处和使用场合

 1>不依赖于对象，执行效率高

 2>开发中能用类方法，尽量用类方法

 3>场合：当方法内部不需要使用到成员变量时，就可以改为类方法

 可以允许类方法和对象方法同名

#import <Foundation/Foundation.h>

@interface Person : NSObject

//类方法都是以+开头
+ (void)printClassName;

- (void)test;
+ (void)test;
@end

#import <Foundation/Foundation.h>
#import "Person.h"
int main(int argc, const char * argv[])
{
    @autoreleasepool {        
        [Person test];
        //这里不用创建对象，直接调用类方法，更利于内存控制
        [Person printClassName];        
        Person *p = [Person new];
        [p test];
        
        /*经典错误
         -[Person printClassName]:unrecognized selector sent to instance ...
         */
        //系统会认为现在调用的printClassName是个对象方法
//        [p printClassName];
        }
    return 0;
}

2.类方法和对象方法区别内存图

3.类方法的练习

用类方法设置一个计算器，求和，求平均值

#import <Foundation/Foundation.h>

//工具类：基本没有任何成员变量，里面的方法基本都是类方法
@interface JiSuanQi : NSObject

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

#import "JiSuanQi.h"
@implementation JiSuanQi
+ (int)sumOfNum1:(int)num1 andNum2:(int)num2
{
    return num1 + num2;
}
+ (int)averageOfNum1:(int)num1 andNum2:(int)num2
{
    //这里直接调用上面的sum方法,下次直接用和除以2，如果数字多不需要这里再加一次，然后再除以2，方便内存管理
    int sum = [self sumOfNum1:num1 andNum2:num2];
    
    return sum / 2;
//    return (num1 +num2) / 2;
}
@end

#import <Foundation/Foundation.h>
#import "JiSuanQi.h"

int main(int argc, const char * argv[])
{
    @autoreleasepool {
        int c = [JiSuanQi sumOfNum1:10 andNum2:78];
        NSLog(@"c = %d",c);
        
        int d = [JiSuanQi averageOfNum1:10 andNum2:56];
        NSLog(@"d = %d",d);        
    }
    return 0;
}

五、self方法

1.概念

self的用途：

 1>概念：指向了当前对象（方法调用者）

  *self出现在对象方法中，self就代表对象

  *self出现在类方法中，self就代表类

 2>可以利用“self->成员变量名”访问当前对象内部的成员变量

 3>[self方法名];

2.使用注意

+ (void)test
{
    NSLog(@"调用了+test方法");
    //这里self是被+ (void)test方法调用，所以指向的是+ (void)test方法。self：指向了当前对象（方法调用者）
    //这里会引发死循环
    [self test];
}

---------------------- <a href="http://edu.csdn.net"target="blank">ASP.Net+Unity开发</a>、<a href="http://edu.csdn.net"target="blank">.Net培训</a>、期待与您交流！ ----------------------