黑马程序员—Objective-C学习—封装、继承、多态

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

三大特性：成员变量的封装、继承、多态

一、封装

写成员变量时，不要写@public，应使用set方法。成员变量尽量不要用@public，不让外界直接访问应提供一个方法给外界设置和访问成员变量的值。即set方法和getf方法。

1、set方法

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

b、命名规范：

(1)、方法名必须以set开头；

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

(3)、形参名称不能跟成员变量同名；

(4)、返回值一定是void；

(5)、一定要接收一个参数，而且参数类型跟成员变量类型一致；

2、get方法

a、作用：返回对象内部的成员变量

b、命名规范：

(1)、肯定有返回值，返回值类型肯定与成员变量一致；

(2)、方法名跟成员变量名一样；

(3)、不需要接收任何参数；

3、只允许外界访问成员变量，不允许外界修改成员变量(只读readonly),只需提供get方法；

      只允许外界修改成员变量，不允许外界访问成员变量,只需提供set方法；

4、封装的好处

(1)、过滤不合理的值；

(2)、屏蔽内部的赋值过程；

(3)、让外界不必关注内部的细节；

5、成员变量的命名规范：一定要以下划线 _ 开头。好处：

a) 可以跟get方法的名称区分开；

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

6、弱语法

调用未定义的方法时，编译有警告，链接可以通过，执行时报错，闪退

//-[Student test]: unrecognized selector   sent to instance 0x7fce28c09710;

//给Student对象发送了一条不能识别的消息：test

OC在运行过程中才会检测对象有没有实现相应方法（动态检测）

7、setter和getter实例

        #import
<Foundation/Foundation.h>

       @interface Student : NSObject

{
   
int _age; 
} 

//set方法

- (void)setAge :(int)newAge;

//get方法
- (int)age;

- (void)study;

@end

@implementation Student

//set方法的实现
- (void)setAge
:(int)newAge
{

   
//对传进来的参数进行过滤
   
if(newAge <=0)
    {
        newAge =
1;
    }
    _age = newAge;
}

//get方法的实现
- (int)age
{
   
return _age;
}

- (void)study
{
    NSLog(@"%d岁的学生在学习",
_age);
}

@end

int main()
{
    Student *stu = [Student new];
    [stu setAge:10];
    [stu study];
    NSLog(@"学生的年龄是%d岁", [stu age]);
   
   
/*

     //-[Student test]: unrecognized selector   sent to instance 0x7fce28c09710;

     //给Student对象发送了一条不能识别的消息：test

     [stu test];

    */
   
return0;
}
8、类方法
a、概念：直接可以用类名来执行的方法(类本身会在内存中占据存储空间，里面有类/对象方法列表)；
b、类方法定义：类方法都是以 + 开头；
c、1>类方法只能用类来调用，不能用对象调用；
     2>对象只能调用对象方法(-)，类不能调用对象方法；
     3>可以允许类方法跟对象方法同名；

     4>类方法内能调用其他的类方法，对象方法内也能调用类方法； 
     5>类方法不能调用自己，会引发死循环；
d、类方法和对象方法区别：
对象方法：
(1)、减号 – 开头；
(2)、只能由对象调用；
(3)、对象方法中能访问当前对象的成员变量；
类方法：
(1)、加号 + 开头；
(2)、只能由类(名)调用；
(3)、成员变量不能在类方法中访问；
e、类方法的好处和使用场合
(1)、不依赖于对象，执行效率高；
(2) 、能用类方法尽量用类方法；
(3) 、场合：当方法内部不需要使用成员变量时，就可以改为类方法；
f、工具类：基本没有任何成员变量，里面的方法基本都是类方法；
g、类方法实例

#import
<Foundation/Foundation.h>
@interface Person : NSObject

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

@end

@implementation Person
+ (void)printClassName
{

    NSLog(@"这个类叫做Person");
}
- (void)test
{
    NSLog(@"调用了test方法"); 
  
    [Person printClassName];
}

@end

int main()
{
   
/*

     Person *p = [Person new];

     //系统会认为现在调用的printClassName是个对象方法

     [p printClassName];这个是错误的，报不能识别消息错误，他找的是对象方法(-)，在对象里面找printClassName对象方法

    */
     [Person printClassName];
   
/*

     //系统会认为现在调用的test是个类方法

     [Person test];//在类里面找test，找不到test类方法

    */  
   
return 0;
}
h、self关键字
(1)、self是个指针，指向调用当前方法内变量，代表着当前变量。
(2)、谁调用了当前方法，self就代表谁；self出现在对象方法中，self代表对象，self出现在类方法中，self代表类；
(3)、在对象方法中，可以利用“self->成员变量名”访问当前对象内部的成员变量；
         [self 方法名]，可以调用其他对象方法或类方法。

二、继承

1、概念：某一个类A继承另一个类B，就可以拥有那个类的所有成员变量和方法。
1>A叫做子类，B叫做父类；
2>所有的类最终继承根类，根类(最基本的类)：NSObject
3>每个类中都有一个superclass指针指向父类；
2、继承的好处：
a、抽取重复代码，不改变原来模型的基础上，拓充代码；
b、建立了类之间的关系；
c、子类可以拥有父类中的所有成员变量和方法。
3、继承的使用场合
a、当两个类拥有相同属性和方法的时候，就可以将相同的东西抽取；
b、当A类完全拥有B类中的部分属性和方法时，可以考虑让B类继承A类；
4、继承的专业术语
1>父类\超类    superclass
2>子类   subclass\subclasses
5、继承的注意点
a、单继承
b、不允许子类和父类拥有相同名称的成员变量；
c、子类可以重写父类的方法，子类重新实现父类中的某个方法，覆盖父类以前的做法；
1>父类必须声明在子类之前；
2>调用某个对象的方法时，优先去当前对象中找，如果找不到，去父类中找；
d、继承的坏处：耦合性太强(类之间的关系太紧密);
6、继承实例

#import <Foundation/Foundation.h>

/********Animal********/
@interface Animal : NSObject
{
    int _age;
    double _weight;
}
- (void)setAge:(int)age;
- (int)age;

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

@end

 

@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]);
    return0;
}
7、super作用：

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

8、继承和组合的区分：

继承：XX是XXX；组合：XX拥有XXX；
继承：
@interface A : NSObject
{
int _age;
}
@end
@interface B : A
{
int _weight;
}
@end
组合：
@interface A : NSObject
{
int _age;
}
@end
@interface B : NSObject
{
A _a;
int _weight;
}
@end

三、多态

1、基本概念：某一类事物的多态性，OC对象具有多态性
2、没有继承就没有多态；
a、代码体现：用父类类型的指针指向子类对象；
b、调用方法时，会检测对象的真实类型，调用的是真实类型的方法。
3、多态的好处：当遇到多个函数，每个方法相差不大，用父类接收参数，节省代码。(将多个函数合成一个函数)
4、多态的局限性：父类类型的变量，不能用来调用子类特有的方法。必须强转为子类类型变量后，才能直接调用子类特有的方法。
5、多态实例：

#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)eat
{

    NSLog(@"Dog--吃东西----");
}
- (void)run
{

    NSLog(@"Dog--跑起来----");
}

@end

@interface Cat : Animal

@end

@implementation Cat
- (void)eat
{

    NSLog(@"Cat--吃东西----");
}

@end

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

int main()
{
    Dog *d = [Dog new];
    [d run];
    
    Animal *aa = [Dog new];

   
//多态的局限性：父类类型的变量不能用来调用子类的方法

   
//[aa run];
    

   
//将aa转为Dog *类型的变量
    Dog *dd = (Dog *)aa;
    [dd run];
    
   
/*

    Dog *dd = [Dog new];

    feed (dd);

    

    Cat *cc = [Cat new];

    feed(cc);

     */
   
/*

    //多种形态

    Dog *d = [Dog new];//Dog类型

    [d eat];

    

    //多态：父类指针指向子类对象

    Animal *a = [Dog new];

    

    //调用一个方法时会检测对象的真实类型

    [a eat];

    */
   
return 0;
}