对象方法 nil值

IOS学习第14天

类的实现和声明

• 无参数的方法的声明和实现调用

1.定义一个学生类(有方法)


无参数方法声明:
     - (void)doHomework;
    - (返回值类型)方法名;"注意写代码的位置在哪?
无参数方法实现:
    - (void)doHomework
    {
        NSLog(@"抄作业....~");
    }

    - (返回值类型)方法名 "注意写代码的位置在哪?
    {
        //实现
    }
2.创建对象调用方法
    格式:[对象名 方法名];

"代码如下
    #import <Foundation/Foundation.h>
    /*
     Student
     属性:名字,年龄,学号,成绩
     方法:做作业,听音乐

     */
    @interface Student : NSObject
    {
        //成员变量
        NSString * _name;
        int _age;
        int _sno;
        float _score;
    }
    //方法的声明
    //- (返回值类型)方法名;
    /**
     *  做作业方法的声明
     */
    - (void)doHomework;

    /**
     *  听音乐方法的声明
     */
    - (void)tingYinYue;

    @end

    @implementation Student

    //方法的实现
    /**
     *  做作业方法的实现
     */
    - (void)doHomework
    {
        //实现
        NSLog(@"抄作业....");
    }
    /**
     *  听音乐方法的实现
     */
    - (void)tingYinYue
    {
        NSLog(@"听音乐 啊啊啊啊啊~~");
    }

    @end

    int main(int argc, const char * argv[]) {
        //    1.定义一个学生类(有方法)
        //
        //    2.创建对象调用方法
        //类中的方法 不能直接调用
        Student * zhangsanfeng = [Student new];//1.2.3

        //格式 [对象名 方法名];

        [zhangsanfeng tingYinYue];
        [zhangsanfeng doHomework];
        return 0;
    }
    ```

* 带1个参数的方法的声明实现调用

“定义一个狗类,有参数的方法

1.有参数的方法的声明
- (返回值类型)方法名:(参数类型)参数名字;
- (void)eat:(NSString *)foodName;

2.有参数的方法的声明
- (返回值类型)方法名:(参数类型)参数名字{}
- (void)eat:(NSString *)foodName
{

}

3.调用带一个参数的方法:
方法 不能直接调用
[对象名 方法名:实际参数];
//调用方法
[wangcai eat:@”shi”];
[wangcai drink:@”水”];

“代码如下
#import

1.定义狗类,要求有两个参数的方法
    - (返回值类型)方法名字:(数据类型1)形参名字1 :(数据类型2)形参名字2;


2.方法的调用
    [对象名 方法名:实参1 :实参2];

"代码如下
    /*

     1.定义狗类,要求有两个参数的方法,又吃又喝,旺财会算术(只会算2个数的加法)



     2.方法的调用

     */
    #import <Foundation/Foundation.h>
    //
    @interface Dog : NSObject
    {
        //成员变量
        int _age;
        NSString * _color;
        NSString * _kind;
    }

    //又吃又喝 方法的声明
    - (void)eatAndDrink:(NSString *)foodName :(NSString *)drinkName;

    //求两个数的和的方法
    - (int)sum:(int)num1 :(int)num2;

    @end
    @implementation Dog
    //又吃又喝 方法的实现
    - (void)eatAndDrink:(NSString *)foodName :(NSString *)drinkName
    {
        NSLog(@"旺财 一边吃着%@,一边喝着%@,还吧唧着嘴",foodName,drinkName);
    }
    - (int)sum:(int)num1 :(int)num2
    {
        int sum = num1 + num2;
        return sum;
    }

    @end

    int main(int argc, const char * argv[]) {
        Dog * wangcai = [Dog new];

        //调用2个参数的方法
        [wangcai eatAndDrink:@"shi" :@"niao"];
        int rel = [wangcai sum:10 :20];

        NSLog(@"rel = %d",rel);
        return 0;
    }
    ```

* 方法的命名规范

建议的方法格式:
- (返回值类型)xxxWithxxx:(数据类型)参数名 and:(数据类型)参数名;

//学生类有方法: 一边看书(需要书名) 一边听音乐(需要歌曲名)

• (void)readingWithBookName:(NSString )bookName andMusicName:(NSString )musicName;

//调用的时候,上面的方法的方法名字是什么?readingWithBookName: andMusicName:

[xiaohong readingWithBookName:@”金瓶梅” andMusicName:@”葫芦娃”];

pragma mark - 0_29 同1个类的多个对象之间毫无关系 [掌握]

1.同一个类可有 无数个对象 对象之间是毫无关系的

2.每一个对象 都有一份自己的成员变量,不受其他对象的影响

3.类 就像一张图纸,对象通过图纸制造出来的东西

“练习:
/*
定义一个手机类,写属性 和方法 并且在主函数中调用
*/
“代码如下

#import <Foundation/Foundation.h>

@interface Phone : NSObject
{
    //成员变量
    NSString * _logo;//品牌
    float _price;//价格
    int _memorySize;//内存大小
}

//发短信
- (void)sendMessage:(NSString *)message toPhoneNumber:(NSString *)phoneNumber;

//打电话
- (void)callWithNumber:(NSString *)phoneNumber;

//看电影
- (void)lookMovie;

@end

@implementation Phone

//发短信
- (void)sendMessage:(NSString *)message toPhoneNumber:(NSString *)phoneNumber
{
    NSLog(@"给 %@ 发短信,内容是%@",phoneNumber,message);
}

//打电话
- (void)callWithNumber:(NSString *)phoneNumber
{
    NSLog(@"给 %@ 打电话,嘟嘟~~~",phoneNumber);
}
//看电影
- (void)lookMovie
{
    NSLog(@"啊啊啊 真好看");
}
@end

int main(int argc, const char * argv[]) {
    //创建一个电话对象
    Phone * iPhone6s = [Phone new];
    //用对象 来干啥事
    [iPhone6s lookMovie];
    [iPhone6s callWithNumber:@"13838385438"];
    [iPhone6s sendMessage:@"SB" toPhoneNumber:@"10086"];

    return 0;
}
```

• 在方法中的实现中直接访问属性

1.以 "-"开头的方法 叫做对象方法:
    顾名思义:只有对象可以调用的方法

2.在 "-"方法内部,可以直接访问属性,那么访问的就是调用这个方法的对象的属性

    #import <Foundation/Foundation.h>

    @interface Pig : NSObject
    {
        @public
        NSString * _name;
        int _IQ;//智商
        float _weight;//体重
    }

    //叫:在这个方法中 喊出自己的名字 智商 和体重
    - (void)bark;

    @end

    @implementation Pig

    - (void)bark
    {
        //在对象方法 的实现中可以直接访问属性
        //谁调用 那么_name 就是谁的name
        NSLog(@"我叫 %@,我的体重高达 %.2lf,我的智商低至%d",
              _name,
              _weight,
              _IQ
              );
    }

    @end

    int main(int argc, const char * argv[]) {
        //创建一个 �� 对象
        Pig * bajie = [Pig new];
        bajie->_name = @"天棚哥哥";
        bajie->_weight = 400.4f;
        bajie->_IQ = 50;

        Pig * maidou = [Pig new];
        maidou->_name = @"麦兜弟弟";
        maidou->_weight = 300.0f;
        maidou->_IQ = 100;


        //    [bajie bark];
        //    [maidou bark];

        return 0;
    }
    ```

* **类加载**

当我们运行程序,第一次使用某个类的时候,会把类的二进制加载到内存的代码段中

* **对象在内存中的存储**

1.在堆区开辟存储空间

2.在这个空间内根据存在于代码段中的类的模板创建一个类,并具有类所有的属性,同时,也会在此空间自动加上一个isa指针,该指针指向了存在于代码段中的类,存的是位于代码段中的类的地址

3.初始化成员变量的值,基本数据类型初始化为0,C的指针的默认值是NULL,OC的指针的默认值是nil

4.最后再将存在于堆中的对象的地址返回给声明在栈区的指针

* **为什么对象中只有类的属性和isa指针**

1.在同一个类中,不同对象所调用的方法都是相同的

2.在同一个类中,不同的对象的属性值是不一样的

**所以对象中只存储自身的属性,而存储一个isa指针指向这个类,就是通过这个isa指针访问对象中的方法**

* nil值

“地址:是一个16进制数 0x0

1.nil
#define nil __DARWIN_NULL
#define __DARWIN_NULL ((void *)0)
Person * p1 = nil;
//让p1不指向任何对象

2.NULL
# define NULL ((void*)0)
int * p1 = NULL;
//让p1不指向任何变量

//nil和NULL本质是完全等价

3.如果一个对象的指针 是 nil;
通过nil访问对象的成员变量的时候 程序会崩溃
通过nil调用对象的方法的时候,什么现象都没有
“`

• 方法与函数的区别

“`
1.函数是C语言的,由于OC兼容C,所以可以在OC的代码中定义和使用函数

2.方法是属于OC的,只能定义在类中.

3.函数和方法定义的位置
1>函数 除了在类声明部分不能写,函数内部不能写,其他任何地方都可以写.
2>方法 声明只能在@interface的大括号外 实现只能在@implementation中
4.调用形式不同:
1>函数直接调用
2>对象方法:只能通过对象来调用
“`
* 注意点

1.@interface和@implemention不能互相嵌套

2.类必须具有类的声明和实现

3.特殊情况下,可以只有类的实现,而没有类的声明

4.类的声明必须要写在类的实现之前

5.类的方法只能通过对象来调用

6.在声明类的属性的时候不能进行初始化

7.当只有类的声明而没有类的实现的时候,会报一个未能识别的方法的错误

8.@end不能省略

9.类的声明必须要放在类使用之前,而类的实现可以放在类使用之后