黑马程序员_第七天视频学习类和对象的三大特性

来源：互联网发布：溢思得瑞人工智能编辑：程序博客网时间：2024/05/20 11:37

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

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

一、成员变量的封装

a、set和get方法

成员变量不应能直接访问，应提供一个方法给外界设置成员变量的值。
1、 set方法

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

i. 方法名必须以set开头；

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

iii. 形参名称不能跟成员变量同名；

iv. 返回值一定是void；

v. 一定要接收一个参数，而且参数类型跟成员变量类型一致；

写成员变量时，不要写@public，应使用set方法。

2、 get方法

a) 作用：返回对象内部的成员变量
b) 命名规范：

i. 肯定有返回值，返回值类型肯定与成员变量一致；

ii. 方法名跟成员变量名一样；

iii. 不需要接收任何参数；

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

4、封装的好处

a)      过滤不合理的值；
b)      屏蔽内部的赋值过滤；
c)      让外界不必关注内部的细节；

5、封装的细节

成员变量的命名规范：一定要以下划线 _ 开头
好处：
a)可以跟get方法的名称区分开；
b)可以跟局部变量区分开，一看到下划线开头的变量，一般都是成员变量；

6、弱语法

一旦程序运行过程中出错，就会闪退；

#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岁",[stuage]);

    /*
     //-[Studenttest]: unrecognized selector sent to instance 0x7fce28c09710;
     //给Student对象发送了一条不能识别的消息：test
     [stu test];
    */
    return 0;
}

b、类方法

1、概念：直接可以用类名来执行的方法(类本身会在内存中占据存储空间，里面有类/对象方法列表)；

2、类方法定义：类方法都是以 + 开头；

类方法只能用类来调用，不能用对象调用；

对象只能调用对象方法(-)，类不能调用对象方法；

可以允许类方法跟对象方法同名；

3、类方法和对象方法区别：

对象方法：

a)      减号 – 开头；
b)      只能由对象调用；
c)      对象方法中能访问当前对象的成员变量；

类方法：

a)      加号 + 开头；
b)      只能由类(名)调用；
c)      成员变量不能在类方法中访问；

4、类方法的好处好使用场合

a) 不依赖于对象，执行效率高；

b) 能用类方法尽量用类方法；

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

5、工具类

基本没有任何成员变量，里面的方法基本都是类方法；

类方法内能调用其他的类方法，对象方法内也能调用类方法；

类方法不能调用自己，会引发死循环；

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

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

- (void)test;

@end

@implementation Person

+ (void)printClassName
{
    NSLog(@"这个类叫做Person");
}

- (void)test
{
    NSLog(@"调用了test方法");

    [PersonprintClassName];
}
@end

int main()
{
    /*
     Person *p =[Person new];
     //系统会认为现在调用的printClassName是个对象方法
     [pprintClassName];这个是错误的，报不能识别消息错误，他找的是对象方法(-)，在对象里面找printClassName对象方法
    */
     [PersonprintClassName];
    /*
     //系统会认为现在调用的test是个类方法
     [Persontest];//在类里面找test，找不到test类方法
    */

    return 0;
}

c、self关键字

self是个指针，指向调用当前方法内变量，代表着当前变量。

1)    概念：睡调用了当前方法，self就代表谁；self出现在对象方法中，self代表对象，self出现在类方法中，self代表类；
2)    在对象方法中，可以利用“self->成员变量名”访问当前对象内部的成员变量；
3)    [self 方法名]，可以调用其他对象方法或类方法。

二、继承

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

#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 = [Dognew];
    [d setAge:10];
    NSLog(@"age = %d",[d age]);
    return 0;
}

7、继承和组合的区分

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

8、继承关键字super

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

三、多态(多种形态)

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

#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 = [Dognew];
    [d run];

    Animal *aa =[Dog new];
    //多态的局限性：父类类型的变量不能用来调用子类的方法
    //[aa run];

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

    /*
    Dog *dd = [Dognew];
    feed (dd);

    Cat *cc = [Catnew];
    feed(cc);
     */
    /*
    //多种形态
    Dog *d = [Dognew];//Dog类型
    [d eat];

    //多态：父类指针指向子类对象
    Animal *a =[Dog new];

    //调用一个方法时会检测对象的真实类型
    [a eat];
    */
    return 0;
}

四、NSString

字符串处理类
OC的字符串也是一个对象
输出方式：%@ ；
最简单的字符串创建方式

NSString*str = @”人”;

NSLog(@”我是一个%@”,str);

创建OC字符串的另一种形式

intage = 10;

NSString*name = @”张三”;

NSString*newstr = [NSString stringWithFormat:@”姓名%@,年龄%d岁”,name,age];

NSLog(@”%@”,newstr);

计算字符串长度

int size = [newstr length]; //算的是字数，并不是字符数。

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

0 0

黑马程序员_第七天视频学习 类和对象的三大特性

黑马程序员_第七天视频学习类和对象的三大特性