[Objective-c]第三天

复习与总结：

  1. 对象在内存中的存储.

  Person *p1 = [Person new];

  2. nil与NULL

  a. 只能作为指针变量的值 代表不指向任何空间.

    (它们是等价的 OC类指针用nil C语言指针用NULL )

  3. 多个指针指向同1个对象.

  4. 分组导航标记.

  5. 方法与函数.

  6. 犯错列表.

  7. 对象与方法.

   1). 类的本质是我们自定义的1个数据类型.

   Person *p1;

   2). 类既然是1个数据类型.那么类 类型的 指针变量完全可以当做方法的参数或者返回值

   3). 当类作为方法的参数的时候. 在方法执行的时候 参数只是1个指针而已 没有创建对象.

    为参数传值以后. 形参指针和实参指针指向了同1个对象.

   在方法的内部通过实参指针去访问对象 访问的就是实参指针指向的对象2.

   4). 对象作为方法的返回值.

   方法的作用就是创建1个对象 把这个对象的地址返回给调用者.

   5).

  8. 表示平面上的1点:

    x左边 和y坐标.

 01-异常处理

 1. 什么是错误?

  一般情况下,错误指的是我们写的源代码不符合语法规范. 然后编译报错.

  后果: 程序无法编译.

  解决: 将不符合语法规范的代码改为符合语法规范的代码不就可以了吗.

 2.什么是Bug?

  程序可以编译 链接  执行.程序执行的结果并不是我们所预想的那样.

  解决: 通过调试寻找发生Bug的原因.

 3.什么是异常?

  程序可以编译 链接 执行.

  当程序在执行的时候 处于某种特定条件下 程序的执行就会终止.

  异常的后果: 程序会立即崩溃.程序立即终止运行.并且后面的代码不会执行了

 4. 如何处理异常.

  1). 目的: 为了让程序在执行的时候如果发生了异常而不崩溃 而是继续往下执行.

  2). 语法:

  @try

  {

  }

  @catch(NSException *ex)

  {

  }

  将有可能发生异常的代码放在@try中.

  当@try中的代码在执行的时候.如果发生了异常.不会崩溃,而是会立即跳转到@catch中去执行里面的代码.

  当@catch的代码执行完毕之后 结束@try...@catch往下执行.

  如果@try中的代码在执行的时候 没有发生异常. 就会略过@catch往下执行.

  3). 当@try中的代码在执行的时候发生了异常.@try块发生异常的后面的代码不会执行.而是立即转到@catch

 5. @catch中的代码只有在@try的代码发生异常的时候才会执行.

  所以,@catch中我们一般情况下写处理异常的代码.

  发生这个异常以后 要做神马事情.

 6. @catch的参数NSException *ex 通过%@打印出ex指向的对象的值.

  可以拿到发生异常的原因

 7. @try...@catch后面还可以跟1个@finally

    @finally中的代码.无论@try中是否发生了异常都会被执行.

 8. @try..@catch并不是万能的.不是所有的运行时错误都可以处理的.

    C语言的异常是无法处理的。

    在实际的开发过程中 使用@try用的相对比较少的.

    避免异常我们最常用的方式还是逻辑判断.

 02-类方法

 0. 在1个Target中无法访问另外1个Target中的类.

 1. OC中的方法分为两种.

  1).对象方法/实例方法:

    我们之前学习的方法 就叫做对象方法.

    如果想要调用对象方法就必须要先创建对象 通过对象名来调用.

  2).类方法.

 类方法的调用不依赖于对象.如果要调用类方法 不需要去创建对象.而是直接通过类名来调用.

 2. 声明.

  1).对象方法的声明:

  对象方法声明使用 - 号

  - (返回值类型)方法名; 

- (void)sayHi;

  2).类方法的声明:

  类方法声明使用 + 号.

          + (返回值类型)方法名;

  和对象方法的声明实现除了+和- 其他的都是一样的

 3.调用.

   1). 对象方法: 先创建对象 再通过对象名来调用.

   2). 类方法: 不需要通过对象名来调用 所以如果要调用类方法不需要创建对象.

         而是直接使用类名来调用:

          [类名 类方法名];

 4.分析一下 类方法和对象方法的调用过程.

  类方法的特点

  1). 节约空间: 因为调用类方法不需要创建对象. 这样就节约了空间.

  2). 提高效率: 因为调用类方法不需要拐弯 直接找到类 直接执行类中的类方法.

 5. 在类方法中不能直接访问属性.

  1). 属性是在对象创建的时候.跟随着对象一起创建在对象之中.

  2). 类第1次被访问的时候,会做类加载. 是把类的代码存储在代码段

  因为属性只有在对象创建的时候才会创建在对象之中.

  而类方法在执行的时候.有可能还没有对象. 对象都没有 你访问个毛的属性.

  虽然不能直接访问属性. 但是我们可以在类方法中创建1个对象 访问这个对象的属性.

 6. 在类方法中也不能通过self直接调用当前类的其他的对象f方法

  因为对象方法只能通过对象来调用 而这个时候没有对象.

 7. 在对象方法中可以直接调用类方法.

 8. 什么时候我们可以将方法定义为类方法呢?

    如果方法不需要直接访问属性 也不需要直接调用其他的对象方法.

    那么我们就可以将这个方法定义为类方法

    这样就 节约空间 提高效率.

 9. 关于类方法的规范.

  1). 如果我们写1个类,那么就要求为这个类提供1个和类名同名的类方法.

  这个方法创建1个最纯洁的对象返回.

  因为苹果和高手写的类都遵守这个规范.

  2). 如果你希望创建爱的对象的属性的值由调用者指定 那么就为这个类方法带参数.

  类名WithXXX: ......

 03-NSString

 1. NSString是1个数据类型.用来保存OC字符串的.

 2. 其实NSString是Foundation框架中的1个类.

  作用: 存储OC字符串的

  所以.OC中的字符串本质上是用NSString对象来存储的.

 3. 其实完整的标准的创建NSString对象的方式

NSString *str0 = [NSString new];
NSString *str1 = [NSString string];

  这种方式创建的字符串是空字符串 @""

  但是.NSString是我们最常用的1个对象 所以OC使用了1种更为简单的方式来创建字符串对象.

  直接使用@来表示1个OC字符串.

  @"jack" 这个其实本质上是1个NSString对象.

NSString *str = @"jack";

  @"jack" 是1个NSString对象  str的值是这个对象的地址.

  %p 打印的是指针变量的值

   %@ 打印的是指针变量指向的对象.

 4. NSString最常用的类方法.

  1).作用:将C语言的字符串转换为OC字符串对象.

+ (instancetype)stringWithUTF8String:(const char *)nullTerminatedCString;

  instanceType 作为返回值 代表返回的是当前这个类的对象.

  2).作用: 拼接1个字符串对象.使用变量或者其他数据拼接成OC字符串.

+ (instancetype)stringWithFormat:(NSString *)format, ... 

使用频率100分.

  int age = 19;

  NSString *name = @"小明";

  //@"大家好我叫xx 我的年龄是xx"

  NSString *str =  [NSString stringWithFormat:@"大家好,我叫%@,我今年%d岁",name,age];

  NSLog(@"str = %@",str);

  5. 最常用的对象方法

   1). length方法 返回值为NSUInteger 其实就是unsigned long

NSUInteger len = [str length];

   得到字符串的字符的个数 可以处理中文.

   2). 得到字符串中指定下标的字符.

   - (unichar)characterAtIndex:(NSUInteger)index;

    unichar chr =[str characterAtIndex:1];

   返回值是unichar 其实就是unsinged short 占据2个字节.

   如果要输出unichar变量的值使用%C 钛金眼睁大 这是大写的C

    NSString * name= @"王大锤";
    int age = 20;
    NSString *str = [NSString stringWithFormat:@"大家好，我叫%@,我今年%d岁",name,age];
    NSLog(@"%@",str);
    NSUInteger len = [str length];
    unichar chr =[str characterAtIndex:1];
    NSLog(@"len = %lu, chr = %C",len,chr);

   3). 判断两个字符串的内容是否相同.

    a. 判断两个字符串的内容是否相同 不要用==去判断  因为这样有可能会出问题.

    b. 判断相等的方式.

   - (BOOL)isEqualToString:(NSString *)aString;

    BOOL res = [str1 isEqualToString:str2];

    NSString * str1= @"1";
    NSString * str2= @"2";

    NSString * showMessage = @"";
    if ([str1 isEqualToString:str2]==YES)
    {
        showMessage = @"内容相同！";
    }
    else
    {
        showMessage = @"内容不同！";
    }

所以,判断两个字符串是否相等 应该使用这个方法区判断 才会得到正确的结果.

  4).比较字符串的大小.

    int res = [str2 compare:str1];

   - (NSComparisonResult)compare:(NSString *)string;

   完全可以使用int类接收结果. 因为返回值是1个枚举.

   返回值如果是 -1 说明小于

   0  等于

   1  大于.

    NSString * str1= @"1";
    NSString * str2= @"2";

    NSString * showMessage = @"";
    if ([str1 isEqualToString:str2]==YES)
    {
        showMessage = @"内容完全相同！";
    }
    else
    {
        int res = [str1 compare:str2];
        switch (res)
        {
            case 1:
                showMessage = @"str1大于str2";
                break;
            case -1:
                showMessage = @"str1小于str2";
            default:
                break;
        }
    }
    NSLog(@"【str1 与 str2 相对比】: %@",showMessage);

 04-匿名对象

 1. 我们之前创建对象的做法.

  Person *p1 = [Person new];

  让1个指针指向1个对象 这个指针就叫做这个对象的名字.

 2. 匿名对象.

  没有名字的对象,如果我们创建1个对象,没有用1个指针存储这个对象的地址.

  也就是没有任何指针指向这个对象 那么这个对象就叫做匿名对象。

 3. 如何去使用1个匿名对象呢?

  因为new实际上1个类方法. 这个方法做的事情创建对象(4个步骤). 返回值是创建的对象的地址.

  [Person new] 这句代码的结果实际上就是创建的那个对象的指针. 那我们可以直接使用.

  [Person new]->_name = @"jack";

  [[Person new] sayHi];

 4. 注意点.

  1). 匿名对象只能使用1次.

  2). 每次创建匿名对象都是不同的对象 。

  [Person new]->_name = @"jack"；//  创建了1个对象
  [Person new]->_age = 18; //  又创建了1个对象
  [[Person new] sayHi]; //  第3个对象.

 5.有神马用?

  1). 如果某个对象的成员只会被我们使用1次.用完之后这个对象再也不需要了 那么就可以使用匿名对象.

  2). 如果方法的参数是1个对象,而调用者为这个参数赋值的对象 就是专门来给这个方法传递的

 并且这个对象调用者不会使用 那么这个时候就可以直接为方法传递1个匿名对象 。

 05-属性的封装

 1. 面向对象的三大特征是什么?

  封装     

          类就是更高级别的封装.类将数据和行为封装为了1个整体.

          好处:

          -> 屏蔽内部的实现.外界不需要知道内部是如何实现的 只需要知道这个对象有什么用.

          -> 方便操作.

          -> 后期的维护十分的便利.

  继承

  多态

 2. 存在的问题.

   就是为对象的属性赋值的时候 语法上其实只要数据的类型是属性的类型就是可以的.

  但是,情理上这么做是不合的.

  就像Person对象有1个int类型的属性_age 表示1个人的年龄.

  为这个对象的_age属性赋值的时候 其实只要是int类型的数据 语法上都是完全可以的.

  但是1个人的年龄 正常情况下是在 0-200之间的.

  解决的问题:

  在为对象的属性赋值的时候,我希望将这个数据做1个逻辑验证.

  如果为属性赋的值在这个逻辑范围之内 那么我们就把这个值赋值给属性.否则我们就做默认处理.

  就像我们希望为Person对象的_age属性赋值的时候,要判断1下为_age属性赋的值是不是在0-200之内.

  否则我们就做默认处理.

 3.如何实现这个需求

  1). 将属性的@public去掉.因为一旦写上@public就意味着外界可以直接访问对象的这个属性.

  外界一旦可以直接访问这个属性 那么外界就可以任意的为这个属性赋值 这个时候你拦都拦不住.

  去掉@public 外界就无法直接访问这个属性 也就无法赋值了.

  2). 为类提供1个方法,这个方法专门为这个属性赋值.这个方法我们叫做setter

   a. 这个方法一定是1个对象方法 因为这个要为属性赋值.

   b. 这个方法没有返回值. 因为这个方法做的事情 仅仅是为属性赋值就可以了.

   c. 这个方法的名称必须以set开头. 跟上去掉下划线首字母大写的属性名.

   d. 这个方法一定是有参数的. 参数的类型和属性的类型一致.参数的名称和属性的名称一致(去掉下划线)

   e. 在方法的实现中,判断传入的数据是否符合逻辑.如果符合逻辑则赋值 否则做默认处理.

   f. 外界想要为对象的属性赋值 那么就调用这个对象的setter方法 将要赋值的数据传入给这个方法.

   方法会对这个数据进行验证 如果符合验证 就会吧数据赋值给属性 否则就会做默认处理.

 练习:

 

   3). 这么一写,我们确实可以在为对象的属性赋值的时候做1个逻辑验证了.

   但是问题就是 在外界无法取出属性的值了.

   那就再写1个方法,专门用来返回属性的值.这个方法我们叫做getter方法.

    a. 这个方法一定是1个对象方法 因为这个方法做的事情是拿到属性的值返回.

    b. 这个方法肯定有返回值 返回值的类型和属性的类型一致.

    c. 这个方法的名称直接就是属性的名称(去掉下划线的)

    d. 这个方法没有参数

    e. 这个方法的实现是直接将属性的值返回.

    f. 这个时候,如果外界希望得到属性的值.那么就只需要调用这个getter方法就可以了.

 课堂练习;

 写1个Student类

  属性: 姓名 长度不能小于2 并且不能是@"Mxx" @“Hxx” @"Xxx"  @"无名"

  年龄  0-120  18

  语文  0-150  0

  数学

  英语

  方法: 介绍自己的名字和年龄显示自己的总分数和平均分.

Student.h

#import <Foundation/Foundation.h>

@interface Student : NSObject
{
    NSString *_name;
    int _age;
    float _chinese;
    float _math;
    float _english;
    
}
-(void)setName:(NSString*)name;
-(NSString*)name;
-(void)setAge:(int)age;
-(int)age;
-(void)setChinese:(float)chinese;
-(float)chinese;
-(void)setMath:(float)math;
-(float)math;
-(void)setEnglish:(float)english;
-(float)english;
-(void)sayHi;
@end

Student.m

#import "Student.h"
@implementation Student
-(void)setName:(NSString*)name
{

    if ([name length]>=2
        && (![name isEqual: @"Mxx"])
        && (![name isEqual: @"Hxx"])
        && (![name isEqual: @"Xxx"]))
    {
        _name = name;
    }
    else
    {
        _name = @"无名";
    }
}
-(void)setAge:(int)age
{
    if (age >=0 && age <=120) {
        _age = age;
    }
    else
    {
        _age = 18;
    }
}
-(int)age{
    return _age;
}
-(void)setChinese:(float)chinese
{
    if (chinese >= 0 && chinese <=150) {
        _chinese = chinese;
    }
    else
    {
        _chinese = 0;
    }
}
-(float)chinese{
    return _chinese;
}
-(void)setMath:(float)math
{
    if (math >=0 && math<=150 ) {
        _math = math;
    }
    else
    {
        _math = 0 ;
    }
    
}
-(float)math{
    return _math;
}
-(void)setEnglish:(float)english
{
    if (english>=0 && english<=150) {
        _english = english;
    }
    else
    {
        _english = 0;
    }
}
-(float)english{
    return _english;
}
-(void)sayHi
{
    NSLog(@"我叫%@,今年%d岁，总分:%.1lf,平均分%.1lf",
          _name,
          _age,
          (_chinese + _math + _english),
          (_chinese + _math + _english) / 3 );
}
@end

main.m

#import <Foundation/Foundation.h>
#import "Student.h"
int main(int argc, const char * argv[]) {
    @autoreleasepool {
    
        Student * s1 = [Student new];
        
        [s1 setName:@"王大锤"];
        [s1 setAge:18];
        [s1 setChinese:120.5];
        [s1 setMath:119.5];
        [s1 setEnglish:102];
        [s1 sayHi];
    
    }
    return 0;
}

  4. 都是你的错

  1). 属性的@public修饰符没有去掉.如果没有去掉 就算你的getter setter封装的再牛X 也没有N用.

  2). 搞不清楚对象. 判断参数的值富是否符合逻辑 将参数赋值给属性.

  3). getter setter 方法名极度不规范.

 5. 什么时候需要为属性封装setter和getter？

  1). 只要属性需要被外界访问.就要为这个属性封装setter和getter。

          哪怕在赋值或者取值的时候没有任何逻辑验证.

  2). 如果属性只在类的内部访问.那么就不需要为其封装getter setter

 6. 只读封装与只写封装.

  只读封装: 为属性封装的时候 只提供getter 不提供setter

  只写封装: 为属性封装的时候.只提供setter 不提供getter

 06-对象之间的关系

 对象与对象之间的关系.

 组合关系

 依赖关系

 关联关系

 继承关系

 1. 组合关系.

  1个对象是由多个对象组合起来的.

  比如.计算机对象. 是由主板对象、CPU对象、内存对象、硬盘对象...组合起来的.

  主板、内存、硬盘作为计算机对象的属性.

  那么这个时候,计算机对象和主板、内存、硬盘的关系为 组合关系.

   

    计算机类的属性:

    CPU 内存 主板 显卡 声卡 网卡。。。

    开机 关机 放片.

    1个类是由其他的几个类联合起来组合而成.那么他们之间的关系就叫做组合关系.

    Person类

    属性: 头 身体 脚

 2. 依赖关系

  1个对象的方法的参数是另外1个对象.那么我们就说他们的关系是依赖关系.

  比如,B类是A类方法的参数,我们就说A类依赖于B类.

  美女打电话的例子.

  人类:

   callWithPhone:(Phone *)phone;

  我们就说人类依赖于电话类. 人要打电话 就必须要有电话对象.

  电话类:

  耦合度:  当修改1个对象的时候 对另外1个对象的影响程度.

  1个类修改了 另外1个类就玩完.(高耦合)

  低耦合: 当修改1个对象的时候 对另外1个对象的影响较小甚至没有影响.

  高内聚: 1个对象仅仅做自己相关的事情.

  单一职责原则. 1个类只做自己的事情.别人的事情给别人做.

  eatShit;

 3. 关联关系

  关联体现的是两个类之间语义级别的一种强依赖关系，

  关联关系：1个类作为另外1个类的属性。但是他们不是组合关系，而是一个拥有的关系。

  拥有关系. 关联关系.

  比如我和我的朋友，这种关系比依赖更强、不存在依赖关系的偶然性、关系也不是临时性的，一般是长期性的，

  而且双方的关系一般是平等的。关联可以是单向、双向的。

  表现在代码层面，

  为被关联类B以类的属性形式出现在关联类A中，也可能是关联类A引用了一个类 型为被关联类B的全局变量。

  案例:人使用iPad听歌.

 10-士兵突击

  利用面向对象,模拟如下流程.

  士兵 开枪 射出子弹.

  士兵类:

    属性: 姓名 兵种.

    行为: 开火的方法.

  枪类:

    属性: 型号.射程.子弹数量.

    行为: 射击.

  //子弹类:

  枪有1个弹夹 弹夹中再有子弹.

Soldier.h

#import <Foundation/Foundation.h>
#import "Gun.h"
@interface Soldier : NSObject
{
    NSString *_name;
    NSString *_type;
    Gun *_gun;
}
-(void)setName:(NSString*)name;
-(NSString*)name;
-(void)setType:(NSString*)type;
-(NSString*)type;
-(void)setGun:(Gun*)gun;
-(Gun*)gun;
-(int)fire;

@end

Soldier.m

#import "Soldier.h"

@implementation Soldier
-(void)setName:(NSString*)name{
    _name =name;
}
-(NSString*)name{
    return _name;
}
-(void)setType:(NSString*)type{
    _type=type;
}
-(NSString*)type{
    return _type;
}
-(void)setGun:(Gun*)gun{
    _gun = gun;
}
-(Gun*)gun{
    return _gun;
}
-(int)fire{
    NSLog(@"预备。。。开火。。。。");
    return [_gun shoot];
}

@end

Gun.h

#import <Foundation/Foundation.h>
#import "DanJia.h"
@interface Gun : NSObject
{
    NSString *_model;
    int _sheCheng;
    DanJia * _danjia;
//    int _bulletCount;
}
-(void)setModel:(NSString*)model;
-(NSString*)model;
-(void)setSheCheng:(int)sheCheng;
-(int)sheCheng;
-(void)setDanJia:(DanJia*)danjia;
-(DanJia*)danjia;
//-(void)setBulletCount:(int)bulletCount;
//-(int)bullCount;
-(int)shoot;
@end

Gun.m

#import "Gun.h"

@implementation Gun
-(void)setModel:(NSString*)model{
    _model =model;
}
-(NSString*)model{
    return _model;
}
-(void)setSheCheng:(int)sheCheng{
    _sheCheng = sheCheng;
}
-(int)sheCheng{
    return _sheCheng;
}
-(void)setDanJia:(DanJia*)danjia{
    _danjia = danjia;
}
-(DanJia*)danjia{
    return _danjia;
}
//-(void)setBulletCount:(int)bulletCount{
//    _bulletCount =bulletCount;
//}
//-(int)bullCount{
//    return _bulletCount;
//}
-(int)shoot{
    
    if ([_danjia bulletCount] > 0) {
        NSLog(@"突突突...");
        int count =[_danjia bulletCount];
        count --;
        [_danjia setBulletCount:count];
        NSLog(@"剩余子弹数量：%d",count);
        return count;
    }
    else{
        NSLog(@"子弹没了~");
        return 0;
    }

}

@end

Danjia.h

#import <Foundation/Foundation.h>

@interface DanJia : NSObject
{
    int _maxCapcity;
    int _bulletCount;
}
-(void)setMaxCapcity:(int)maxCapcity;
-(int)maxCapcity;

-(void)setBulletCount:(int)bulletCount;
-(int)bulletCount;

@end

Danjia.m

#import "DanJia.h"

@implementation DanJia
-(void)setMaxCapcity:(int)maxCapcity{
    _maxCapcity =maxCapcity;
}
-(int)maxCapcity{
    return _maxCapcity;
}
-(void)setBulletCount:(int)bulletCount{
    if (_bulletCount>=0 && bulletCount <=_maxCapcity) {
    	_bulletCount = bulletCount;
    }
    else{
        _bulletCount = 10;
    }

}
-(int)bulletCount{
    return _bulletCount;
}
@end

main.m

//
//  main.m
//  士兵突击
//
//  Created by babylon on 2022/5/3.
//  Copyright © 2022年 babylon. All rights reserved.
/*
   士兵 开枪 射出子弹.
 
   士兵类:
 
     属性: 姓名 兵种.
 
     行为: 开火的方法.
 
   枪类:
 
     属性: 型号.射程.子弹数量.
 
     行为: 射击.
 
   //子弹类:
 
   枪有1个弹夹 弹夹中再有子弹.
 
 */

#import <Foundation/Foundation.h>
#import "Soldier.h"
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        DanJia *dj = [DanJia new];
        [dj setMaxCapcity:30];
        Gun *ak47 = [Gun new];
        [ak47 setModel:@"ak47"];
        [dj setBulletCount:19];
        [ak47 setDanJia:dj];
        
        Soldier *xsd =[Soldier new];
        [xsd setName:@"许三多"];
        [xsd setType:@"炮兵"];
        [xsd setGun:ak47];
        
        for (int i = 0 ; i < 30; i++) {
            int res = [xsd fire];
            if (res == 0 ) {
                break;
            }
        }
    }
    return 0;
}

作业：

1./* 再写1个软件工程师类:
 属性:
 姓名(长度不能小于2.否则"无名")、
 基本工资(3000-5000. 否则3000)、
 项目奖金(3500-7000 否则4500).
 
 行为: 介绍自己的方法. 叫xx 每月薪水是多少. */

RuanJianGongChengShi.h 

/* 再写1个软件工程师类:
 属性:
 姓名(长度不能小于2.否则"无名")、
 基本工资(3000-5000. 否则3000)、
 项目奖金(3500-7000 否则4500).
 
 行为: 介绍自己的方法. 叫xx 每月薪水是多少. */

#import <Foundation/Foundation.h>

@interface RuanJianGongChengShi : NSObject
{
    NSString *_name;
    float _jiBenGongZi;
    float _xiangMuJiangJin;
}

-(void)setName:(NSString*)name;
-(NSString*)name;
-(void)setJiBenGongZi:(float)jiBenGongZi;
-(float)jiBenGongZi;
-(void)setXiangMuJiangJin:(float)xiangMuJiangJin;
-(float)xiangMuJiangJin;
-(void)sayHi;
@end

RuanJianGongChengShi.m

#import "RuanJianGongChengShi.h"

@implementation RuanJianGongChengShi


-(void)setName:(NSString*)name
{
    if ([name length] < 2) {
        name = @"无名";
    }
    _name = name;
}
-(NSString*)name
{
    return _name;
}
-(void)setJiBenGongZi:(float)jiBenGongZi
{
    if (jiBenGongZi<3000 || jiBenGongZi>5000)
    {
        jiBenGongZi = 3000;
    }
    _jiBenGongZi = jiBenGongZi;
}
-(float)jiBenGongZi
{
    return _jiBenGongZi;
}
-(void)setXiangMuJiangJin:(float)xiangMuJiangJin
{
    if (xiangMuJiangJin >3500 || xiangMuJiangJin>7000)
    {
        xiangMuJiangJin = 4500;
    }
    _xiangMuJiangJin = xiangMuJiangJin;
}
-(float)xiangMuJiangJin
{
    return _xiangMuJiangJin;
}
-(void)sayHi
{
    NSLog(@"大家好，我是%@,每月薪水是%.1lf(基本工资：%.1lf,项目奖金:%.1lf)",
          _name,
          _jiBenGongZi + _xiangMuJiangJin,
          _jiBenGongZi,
          _xiangMuJiangJin
          );
}
@end

/*

 1. 写1个项目经理类.

 属性: 姓名(长度不能小于2.否则"无名")、

 基本工资(5000-9000. 否则5000)、

 项目分红(10000-20000, 否则10000)、

 项目奖金(4000-9000 否则4000).

 行为: 介绍自己的方法. 叫xx 每月薪水是多少.

 */

XiangMuJingLi.h

/*
 1. 写1个项目经理类.
 属性: 姓名(长度不能小于2.否则"无名")、
 基本工资(5000-9000. 否则5000)、
 项目分红(10000-20000, 否则10000)、
 项目奖金(4000-9000 否则4000).
 
 行为: 介绍自己的方法. 叫xx 每月薪水是多少.
 */
#import <Foundation/Foundation.h>

@interface XiangMuJingLi : NSObject
{
    NSString *_name;
    float _jiBenGongZi;
    float _xiangMuFenHong;
    float _xiangMuJiangJin;
}

-(void)setName:(NSString*)name;
-(NSString*)name;
-(void)setJiBenGongZi:(float)jiBenGongZi;
-(float)jiBenGongZi;
-(void)setXiangMuFenHong:(float)xiangMuFenHong;
-(float)xiangMuFenHong;
-(void)setXiangMuJiangJin:(float)xiangMuJiangJin;
-(float)xiangMuJiangJin;
-(void)sayHi;
@end

XiangMuJingLi.m

#import "XiangMuJingLi.h"

@implementation XiangMuJingLi

-(void)setName:(NSString*)name
{
    if ([name length] < 2) {
        name = @"无名";
    }
    _name = name;
}
-(NSString*)name
{
    return _name;
}
-(void)setJiBenGongZi:(float)jiBenGongZi
{
    if (jiBenGongZi<5000 || jiBenGongZi>9000)
    {
        jiBenGongZi = 5000;
    }
    _jiBenGongZi = jiBenGongZi;
}
-(float)jiBenGongZi
{
    return _jiBenGongZi;
}
-(void)setXiangMuFenHong:(float)xiangMuFenHong
{
    if (xiangMuFenHong<10000 || xiangMuFenHong>20000)
    {
        xiangMuFenHong = 10000;
    }
    _xiangMuFenHong = xiangMuFenHong;
}
-(float)xiangMuFenHong
{
    return _xiangMuFenHong;
}
-(void)setXiangMuJiangJin:(float)xiangMuJiangJin
{
    if (xiangMuJiangJin <4000 || xiangMuJiangJin>9000)
    {
        xiangMuJiangJin = 4000;
    }
    _xiangMuJiangJin = xiangMuJiangJin;
}
-(float)xiangMuJiangJin
{
    return _xiangMuJiangJin;
}
-(void)sayHi
{
    NSLog(@"大家好，我是%@,每月薪水是%.1lf(基本工资：%.1lf,项目分红:%.1lf,项目奖金:%.1lf)",
          _name,
          _jiBenGongZi + _xiangMuFenHong + _xiangMuJiangJin,
          _jiBenGongZi,
          _xiangMuFenHong,
          _xiangMuJiangJin
          );
}
@end

/*

 2. 定义一个圆类Circle，

 包含2个属性，

 圆心point

 圆的半径radius。

 定义两个方法，分别计算圆的面积和周长并显示。

 */

 Circle.h

/*
 2. 定义一个圆类Circle，
 包含2个属性，
 圆心point
 圆的半径radius。
 
 定义两个方法，分别计算圆的面积和周长并显示。
 */

#import <Foundation/Foundation.h>

@interface Circle : NSObject
{
    double _point;
    double _radius;
}

-(void)setPoint:(double)point;
-(double)point;

-(void)setRadius:(double)radius;
-(double)radius;

-(void)showArea;
-(void)showCircumference;
@end

Circle.m

#import "Circle.h"

@implementation Circle

-(void)setPoint:(double)point{
    _point = point;
}
-(double)point{
    return _point;
}

-(void)setRadius:(double)radius{
    _radius = radius;
}
-(double)radius{
    return  _radius;
}

-(void)showArea{
    NSLog(@"这个圆的面积是：%.2lf",
          (3.14*_radius*_radius)
          );
}
-(void)showCircumference{
    NSLog(@"这个圆的周长是：%.2lf",
          (2*3.14*_radius)
          );
    
}
@end

main.m

#import <Foundation/Foundation.h>
#import "Circle.h"
int main(int argc, const char * argv[]) {

    Circle *c1 = [Circle new];
    
    [c1 setRadius:3];
    [c1 showArea];
    [c1 showCircumference];
    
    return 0;
}

 

/*

 3.设计一个类Point2D，用来表示二维平面中某个点

 1> 属性

 * double x

 * double y

 2> 方法

 * 属性相应的set和get方法

 * 设计一个对象方法同时设置x和y

 * 设计一个对象方法计算跟其他点的距离

 * 设计一个类方法计算两个点之间的距离

 3> 提示

 * C语言的math.h中有个函数：double pow(double n, double m); 计算n的m次方

 * C语言的math.h中有个函数：double sqrt(double n); 计算根号n的值（对n进行开根）

 */

Point2D.h

/*
 3.设计一个类Point2D，用来表示二维平面中某个点
 1> 属性
 * double x
 * double y
 
 2> 方法
 * 属性相应的set和get方法
 * 设计一个对象方法同时设置x和y
 * 设计一个对象方法计算跟其他点的距离
 * 设计一个类方法计算两个点之间的距离
 
 3> 提示
 * C语言的math.h中有个函数：double pow(double n, double m); 计算n的m次方
 * C语言的math.h中有个函数：double sqrt(double n); 计算根号n的值（对n进行开根）
 */

#import <Foundation/Foundation.h>

@interface Point2D : NSObject
{
    double _x;
    double _y;
}
-(void)setX:(double)x;
-(double)x;

-(void)setY:(double)y;
-(double)y;

-(void)setX:(double)x andY:(double)y;

-(double)distanceWithOtherPoint:(Point2D*)otherPoint;

+(double)distanceWithPointA:(Point2D*)p1 andPonintB:(Point2D*)p2;

@end

Point2D.m

#import "Point2D.h"
#import <math.h>
@implementation Point2D

-(void)setX:(double)x
{
    _x = x;
}
-(double)x
{
    return _x;
}

-(void)setY:(double)y
{
    _y = y;
}
-(double)y
{
    return _y;
}
-(void)setX:(double)x andY:(double)y
{
    _x = x;
    _y = y;
}
-(double)distanceWithOtherPoint:(Point2D*)otherPoint
{
    double res1 = pow((_x - otherPoint->_x),2);
    double res2 = pow((_y-otherPoint->_y),2);
    double res3 = sqrt(res1+res2);
    return res3;
    
}
+(double)distanceWithPointA:(Point2D*)p1 andPonintB:(Point2D*)p2
{
    double res1 = pow((p1->_x - p2->_x),2);
    double res2 = pow((p1->_y-p2->_y),2);
    double res3 = sqrt(res1+res2);
    return res3;
}
@end

main.m

#import <Foundation/Foundation.h>
#import "Point2D.h"
int main(int argc, const char * argv[]) {

    Point2D *p1 = [Point2D new];
    [p1 setX:100 andY:100];
    
    Point2D *p2 = [Point2D new];
    [p2 setX:200 andY:200];
    
    Point2D *p3 = [Point2D new];
    [p3 setX:500 andY:500];
    
    NSLog(@"p1 和 p2之间的距离为：%.2lf",[p2 distanceWithOtherPoint:p1]);
    NSLog(@"p2 和 p3之间的距离为：%.2lf",
          [Point2D distanceWithPointA:p2 andPonintB:p3]
          );
    
    return 0;
}