OC的基础语法(一)

#import <Foundation/Foundation.h>

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // OC版的HelloWorld
        NSLog(@"Hello, World!");
    }
    return 0;
}

 1）头文件

　　对比c语言中的#include学习


 #include <stdio.h>文件包含，把.h文件的内容拷贝到
 当前些 #include 位置
 
 #import <Foundation/Foundation.h>  文件包含，把.h文件的内容拷贝到
 当前些 #import 位置，Foundation/Foundation.h 这是OC中的一个框架
 
 /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.10.sdk/System/Library/Frameworks
 
    关于include 和 import 的区别：
 
     #include  ""  -用户定义的文件
     #include  <>  -系统的文件
    
     #import <>    -系统的文件
     #import ""    -用户的文件
 
     
     improt 是 include 升级版，自动防止重复包含，即便是重复的包含了，也只有一次包含会起作用
 
  2）main 主入口函数
 
     系统调用主入口函数
 
  3）NSLog,输出内容到控制台
 

/*
 
 1）源文件对比
 
    C               OC
 .c                 .h
 .h                 .m  - OC的源文件
 .o
 .out
 
 
 2）数据类型、运算符
 
    C                OC
 基本数据类型        
 构造类型
 指针类型           
 空类型
 定义类型
                   BOOL      新的类型，存储YES 和 NO
                   id        万能的指针
                   Boolean   布尔类型，跟BOOL相似，存储的时 true 和 false
                   Class     类类型
                   特殊类型 
                        SEL  方法的选择器
                        nil  空的（对象为空）
                        block 块类型
 

 3）关键字、标示符
 
    C               OC
    32关键字         @...
 
 
    注意：C的关键字可以在OC中使用，OC的关键字不能在C中使用
         OC的关键字，大多数都是以 @ 开头
 
 
 4、语句控制（分支和循环）
 
 
    C               OC
  ----------------->
  1)分支
    if
    if else
    if else if else
 
    switch
 
 
  2）循环
    --------------->
    while 
 
    do while
 
    for
 
                   增强型的for循环(OC的快速枚举)
 
                   for in
 
                   格式：
                    for(数组类型 变量名 in 数组){
 
                              变量名;//直接使用，变量每次存储的值是不一样
                    }
 
 
  5、函数定义对比
 
      C                            OC
  返回值 函数名(形参){            OC中的函数不再叫"函数"，叫方法

 
     函数体                     OC中的方法，分为两种：对象方法、类方法
 
  }
 
   
   //函数的调用
   函数名(实参);                 对象方法的调用：[对象名 方法名]
                               类方法的调用：[类名 方法名]

  6、OC中新增加的两个数据类型介绍
 
     逻辑型：BOOL   Boolean
 
     C                       OC
 
     &&                      BOOL
     ||                      Boolean
      !    
 
 
 
     BOOL  存储的时YES和NO
 
      YES 表示真   实际的值 1
      NO  表示假   实际的值 0
 
 
 
     Boolean 存储的时true 和 false
 
     true 表示真   实际值  1
     false 表示假  实际值  0
 
 */


#import <Foundation/Foundation.h>

int main(int argc, const char * argv[]) {
    @autoreleasepool {
      


//        NSArray *arr = @[@"1",@"2",@"3"];
//        
//        for (NSString *str in arr) {
//            
//            //输出字符串的内容
//            NSLog(@"%@",str);
//            
//        }
        
        //1、BOOL 类型
        
        //定义BOOL变量
        BOOL flag = YES; //YES的值是 1
        flag = NO;       //NO的值就是 0
        flag = 3>3;
        printf("floag = %d\n",flag);
        
        
        //2、Boolean类型(布尔类型)
        Boolean f1 = true;  //true 1
        f1 = false;         //false 0
        
        printf("f1 = %d\n",f1);
        
        BOOL flag1 =YES;
        while (flag1) {
            
            flag = NO;
        }
        
        
    }
    return 0;
}

/*
 
 第一个OC类的定义：
 
   类的定义分为两部分：类的声明    类的实现
 
   1）类的声明写法

      格式：
      @interface  类名 :父类名
      {
          //成员变量的声明
      }
 
      //动作（方法）的声明
      @end
 
  
      声明一个学生类：
  
      @interface Student:NSObject
      {
          //属性的定义
          int age;
          int sno;
          float score;
      }
 
      //定义行为
      @end
 
   2）类的实现
 
      格式：
      @implementation 类名
 
 
      @end;
 
 
      实现一个学生类:实际上是实现类中声明的方法
 
      @implementation Student
 
      @end
 
 
      注意：
       1) @interface 、@implementation 、@end 一个oc的关键字
       2) @end 千万不能漏写
       3）类的声明和实现应该是成对出现
 
 
   3）对象的创建
 
         struct Student stu1;
 
         //定义一个Student 类型的变量
         //创建了一个Student类型的对象 对象名是 stu
         Student *stu = [Student new];
 
         [Student new];  //调用Student 的类方法
 
         做了三件事情：
 
         1）在内存的堆区分配一块内存
         2）给存储区域初始化（给类的每一个属性都初始化，基本数据类型，初始化为0，NSString 初始化为null）
         3) 返回刚分配的内存空间的首地址
 
 
    4）声明和实现类中的方法
 ‘
         在类的声明中 在 @interface  和  @end直接，并且在 属性声明的{}之外，就可以
         声明方法了
  
       声明方法：
 
          OC的方法有两个种：对象方法  和  类方法
    
               对象方法的特点：
 
               1）使用 - 号开头
               2）方法的返回值用 小括号括起来
               3）方法的名称严格遵守标示符命名规范
               4）对象想法，只能有 对象调用 
             
                 方法调用的格式：[对象名  方法名];
 
                  1）无参方法
         
                     -(返回值类型)方法名;
 
                     -(void)qiaoKe;
                     -(void)playGame;
                     -(void)tanlove;
         
                     实现：
                    在@implementation  和 @end之间
                     -(void)qiaoKe{
 
                     }
 
         
                  2）有参数的方法
 
                     （1）有一个参数的对象方法
 
                     -(返回值类型)xxx:(形参类型) 形参名;
  
                       注意：方法名:"xxx:"
 
                       调用：[对象名 方法名:实参];
 
                         实现：
                         在@implementation  和 @end之间
                         -(void)eat:(NSString *) foodName{
                         
                         }
 
                      (2)有二个或者多个参数的对象方法的声明
 
                      -(返回值类型)xxx:(形参类型) 形参名  andSSS:(形参类型) 形参名;
 
                       方法名：
                               xxx:    andSSS:
 
 
                         //声明了两个参数的方法
                         -(void)tlove:(NSString *) gf1 andGirl2:(NSString  *) gf2;
                        调用： [stu  tlove:@"" andGirl2:@""];
 
 
 
 */


#import <Foundation/Foundation.h>

//声明一个学生类
@interface Student:NSObject
{
    //属性（成员变量/实例变量）的定义
    @public
    int age;
    int sno;
    float score;
}

//定义行为
//翘课
-(void)qiaoKe;
//打游戏
-(void)playGame;
//谈恋爱
-(void)tanlove;

//声明了一个吃饭的方法
-(void)eat:(NSString *) foodName;

//声明了两个参数的方法
-(void)tlove:(NSString *) gf1 andGirl2:(NSString  *) gf2;

-(void)tlove:(NSString *) gf1 :(NSString  *) gf2;

@end

//实现一个学生类
@implementation Student

//翘课
-(void)qiaoKe{

    NSLog(@"正在翘课！");
}
//打游戏
-(void)playGame{

   NSLog(@"正在玩都斗地主！");

}
//谈恋爱
-(void)tanlove{

   NSLog(@"正在小花谈恋爱！");
}

//吃的方法
-(void)eat:(NSString *) foodName{

    NSLog(@"正在吃: %@ ",foodName);
}

//声明了两个参数的方法
-(void)tlove:(NSString *) gf1 andGirl2:(NSString  *) gf2{


    NSLog(@"正在和%@交往的同时，和%@也有一腿!\n",gf1,gf2);

}


-(void)tlove:(NSString *) gf1 :(NSString  *) gf2{

     NSLog(@"正在和%@交往的同时，和%@也有一腿!\n",gf1,gf2);

}
@end


int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
        //创建一个学生类的对象
       Student *stu = [Student new];
        
        NSLog(@"age:%d,sno:%d,%.2f",stu->age,stu->sno,stu->score);
        
        //对象stu成员变量赋值
        //OC中默认的在类的外部不能访问类的成员变量
        //用@public 强制访问类的成员变量
        //通过对象stu进行赋值
        stu->age = 23;
        stu->sno = 110;
        stu->score = 56.78;
        
        NSLog(@"age:%d,sno:%d,%.2f",stu->age,stu->sno,stu->score);
        
        //用对象调用对象的方法
        [stu qiaoKe];
        [stu playGame];
        [stu tanlove];
        [stu eat:@"爆炒妙脆角"];
         
        //调用两个参数的方法
        [stu tlove:@"凤姐" andGirl2:@"芙蓉"];
        [stu tlove:@"凤姐" :@"芙蓉"];
        
        
    }
    return 0;
}