黑马程序员——三大特性

---------------------- ASP.Net+Unity开发、 .Net培训、期待与您交流！ ----------------------

很久没有更新博客了，请原谅我散漫的人生。

这几天都窝在家中看ios的基础视频，今天基本快要将面向对象的章节看完了，最迟后天就看内存管理了。

首先面向对象语言都有三大特性。封装，继承，多态。

封装其实很简单，就是想一个类声明之后保护好，不能让外界随意的看到类中的变量，或者修改变量。因此声明的类中变量名之前的@public就应该去掉，而是在类中声明一个set方法和get方法，这样就可以避免开发者不想用户访问或者修改的变量被修改，保护了类的安全，而且调用起来的时候也很方便。

继承，故名思议就是继承者拥有被继承者的所有属性，包括变量和方法。这种方式可以减少开发者大量的工作量，很懂重复的代码就不需要再次写了。

多态，说白了就是一个对象的多种形态。没有继承就没有多态，父类的指针指向子类的对象。多态的好处也是当一个方法需要用父类继承下去的很多子类来调用的时候，在这个对象方法声明的时候只需要将父类的指针传入就行，而后在调用此方法的时候直接将父类的指针指向子类的对象，然后用子类的对象调用这个方法就可以了，这样也会大大减少开发者的代码量。但是多态有一个局限性，就是父类类型的变量不能调用子类的方法

下面是按照老师给的练习写的代码

封装

#import <Foundation/Foundation.h>

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

- (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;
}

继承

#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;
}

多态

#import <Foundation/Foundation.h>

/*
 多态
 1.没有继承就没有多态
 2.代码的体现：父类类型的指针指向子类对象
 3.好处：如果函数\方法参数中使用的是父类类型，可以传入父类、子类对象
 4.局限性：
 1> 父类类型的变量 不能 直接调用子类特有的方法。必须强转为子类类型变量后，才能直接调用子类特有的方法
 */

// 动物
@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(Dog *d)
//{
//    [d eat];
//}
//
//void feed2(Cat *c)
//{
//    [c eat];
//}
//

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

int main()
{
    // NSString *d = [Cat new];
    // [d eat];
    
    
     Animal *aa = [Dog new];
     // 多态的局限性：父类类型的变量 不能 用来调用子类的方法
     //[aa run];
    
     // 将aa转为Dog *类型的变量
     Dog *dd = (Dog *)aa;
     
     [dd run];
     
    
    //Dog *d = [Dog new];
    
    //[d run];
    
    /*
     Animal *aa = [Animal new];
     feed(aa);
     
     Dog *dd = [Dog new];
     feed(dd);
     
     Cat *cc = [Cat new];
     feed(cc);
     */
    
    /*
     // NSString *s = [Cat new];
     Animal *c = [Cat new];
     
     
     NSObject *n = [Dog new];
     NSObject *n2 = [Animal new];
     
     
     // 多种形态
     //Dog *d = [Dog new]; // Dog类型
     
     // 多态：父类指针指向子类对象
     Animal *a = [Dog new];
     
     // 调用方法时会检测对象的真实形象
     [a eat];
     */
    return 0;
}

其中内容里面还讲到了类方法。

内方法顾名思义就是类调用的方法，就是很多时候不需要创建对象直接用类就可以实现的方法就可以使用类方法。

要注意的是类方法的前面是用+ 而对象方法是用的 -

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

#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
{
    int sum = [JiSusnQi 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;
}

---------------------- ASP.Net+Unity开发、 .Net培训、期待与您交流！ ----------------------