oc语法学习(一)(java对比)

发表于 | 分类于 | | 阅读次数

OC程序结构

1.预处理命令（类似java的导入类库）
1
#import <Foundation/Foundation.h>是一个预处理命令，它告诉Objective-C语言编译器去实际编译之前包含Foundation.h文件。
2.接口（类似java的接口）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
1. @interface SampleClass:NSObject 显示了如何创建一个接口。它继承NSObject，这是所有对象的基类。
2.(void)sampleMethod; shows how to declare a method.
3. @end 标志着接口的结束。
4. @implementation SampleClass
- (void)sampleMethod{
   NSLog(@"Hello, World! 
");
}
@end

差异:
1.java中使用interface来定义接口,接口是抽象的，并且里面的方法没有方法体，oc使用@interface来定义接口，但是oc的接口结尾要添加@end来结束
2.java中的继承使用extend，而oc中使用:表示继承(特定下)
3.java中使用implement去实现接口，而oc中使用@implementation实现接口

4.方法
5.语句和表达式
6.注释

OC基本语法

1.标识符

都是由字母，数字，下划线，组成，不允许@，%标点符号，但是java能用$,而oc不能。都以字母或下划线开头。

2.关键字

oc和java一样都不能作为常量或变量，或任何其他标识符名称。

OC数据类型

1.基本类型（整数类型，浮点型）
2.枚举类型（定义变量只能被分配在整个程序中的若干离散的整数值）
3.void类型（类型说明符void表示没有可用的值）
4.派生类型（包括指针类型，数组类型，结构类型，联合类型及函数类型）
差异：oc和java的数据类型差异还是蛮大的，java基本数据类型分为8种（int,float,double,char,short,long,byte,boolean）,其余的是引用数据类型（类，接口，数组）

OC变量

oc中使用extern关键字来申明一个变量，java中申明变量只需要加数据类型就好

1
2
oc: extern int a;
java: int a;

OC常量

在oc中有两种简单的方法来定义常量
1.使用#define预处理
2.使用const关键字

1
2
1.#define identifier value
2.const type variable = value;

在java中一般使用

1
public static final String VALUE = "java";

来定义一个常量

OC运算符

1.算术运算符（+，-，*，/，%，++，–）
2.关系运算符（==,!=,>,<,>=,<=）
3.逻辑运算符（&&,||,!）
4.位运算符（&,|,^,~）
5.赋值运算符（=,+=,-=,…）
6.其他运算符
类似，没什么好说的

OC循环

1.while循环
2.for循环
3.do…while循环
4.内嵌循环
5.break
6.continue
7.if,if…else,switch
类似，没什么好说的

函数

1.定义一个方法
1
2
3
4
5
6
- (return_type) method_name:( argumentType1 )argumentName1 
joiningArgument2:( argumentType2 )argumentName2 ... 
joiningArgumentn:( argumentTypen )argumentNamen 
{
   body of the function
}

·返回类型：方法可以返回一个值。 return_type是函数返回值的数据类型。有些方法执行所需的操作，不返回值。在这种情况下，return_type关键字是void。
返回类型: 方法可以返回一个值。 return_type是函数返回值的数据类型。有些方法执行所需的操作，不返回值。在这种情况下，return_type关键字是void。

·方法名称: 这是实际的方法名。方法名和参数表共同构成的方法签名。

·参数: 一个参数像一个占位符。当函数被调用时，你传递一个值的参数。这个值被称为实际参数或参数。参数列表是指的类型，顺序和数量的参数的方法。参数是可选的，方法可能不包含任何参数。

·连接参数: 连接的参数，使其更易于阅读和同时调用明确。

·方法体: 该方法的主体包含语句定义的方法用于做什么的集合。

在java中定义一个方法，例

1
2
3
public boolean max(int num1,int num2) {
    return num1>num2;
}
2.按值传递参数（例：两数交换）
3.按引用方法调用参数传递（例，指针类型交换）

OC 块

1.简单声明块语法
1
2
3
4
5
6
7
8
returntype (^blockName)(argumentType);
```    
例
 
```java
void (^simpleBlock)(void) = ^{
    NSLog(@"This is a block");
};

调用块

1
simpleBlock();

OC Numbers/数字

1.(NSNumber *)numberWithBool:(Bool)value(将bool转成NSNumber)
2.(NSNumber *)numberWithChar:(char)value(将char转NSNumber)
3.(NSNumber *)numberWithDouble:(double)value(将double转NSNumber)
4.(NSNumber *)numberWithFloat:(float)value(将float转NSNumber)
5. (NSNumber *)numberWithInt:(int)value（将int转NSNumber）
6. (NSNumber *)numberWithInteger:(NSInteger)value(将NSInteger转NSNumber)
7. (BOOL)boolValue(将NSNumber转bool)
8. (char)charValue(将NSNumber转char)
9. (double)doubleValue(将NSNumber转double)
10. (float)floatValue（将NSNumber转float）
11. (NSInteger)integerValue（将NSNumber转NSInteger）
12. (int)intValue(将NSNumber转int)
13. (NSString *)stringValue(将NSNumber转NSString)
14. 而在java中也是类似
1
2
String.valueOf(int);将int转成String
Integer.parseInt(String)将String转int

例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
#import <Foundation/Foundation.h>
//定义一个接口
@interface SampleClass:NSObject
//声明一个方法，返回NSNumber类型，传入连个NSNumber类型参数
- (NSNumber *)multiplyA:(NSNumber *)a withB:(NSNumber *)b;
@end
//接口的实现类
@implementation SampleClass
//抽象方法的具体实现
- (NSNumber *)multiplyA:(NSNumber *)a withB:(NSNumber *)b
{
//将NUNString转成float
   float number1 = [a floatValue];
   float number2 = [b floatValue];
   float product = number1 * number2;
   //将float转成NSNumber输出
   NSNumber *result = [NSNumber numberWithFloat:product];
   return result;
}
@end
int main()
{
   NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
    //创建SampleClass对象
   SampleClass *sampleClass = [[SampleClass alloc]init];
   //将float转NSNumber
   NSNumber *a = [NSNumber numberWithFloat:10.5];
   NSNumber *b = [NSNumber numberWithFloat:10.0];  
   //输出相乘结果 
   NSNumber *result = [sampleClass multiplyA:a withB:b];
   //将结果转成NSString输出
   NSString *resultString = [result stringValue];
   NSLog(@"The product is %@",resultString);
   [pool drain];
   return 0;
}

OC Arrays/数组

1.申明数组
1
type arrayName[arraySize];
2.初始化数组
1
double balance[5] = {12,13,43,45,65};

如上java类似,但是写法还是有点不同

1
2
3
4
//初始化
String[] stringArray = new String[];
//或
String[] stringArray = {"23","12","43","54"}
3.多维数组
1
2
二维数组，同理
type arrayName[x][y]
4.从函数返回数组

注:在OC中不提倡地址返回一个局部变量在函数之外，所以必须将局部变量定义为静态变量，这和java很不同，java是允许直接将局部变量返回的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
@implementation SampleClass
/* function to generate and return random numbers */
- (int *) getRandom
{
  static int  r[10];
  int i;
  /* set the seed */
  srand( (unsigned)time( NULL ) );
  for ( i = 0; i < 10; ++i)
  {
     r[i] = rand();
     NSLog( @"r[%d] = %d
", i, r[i]);
  }
  return r;
}
@end
5.指针的数组

数组名是一个常量指针数组的第一个元素

1
2
3
4
5
double *p;
double balance[10];
p = balance;
p所指向的就是balance[0]的地址

使用数组名作为常量指针，使用*（balance+4）是一种合法的方式访问数据balance[4]。

OC指针

指针是一个变量，其值是另一个变量，即直接地址的内存位置的地址。
使用时：
1.定义一个指针变量
int *ip;
2.分配一个指针变量的地址
ip = &var;
3.访问提供的地址指针变量的值
例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#import <Foundation/Foundation.h>
int main ()
{
//定义一个变量
   int  var = 20;   /* actual variable declaration */
   //申明一个指针
   int  *ip;        /* yiibaier variable declaration */
//将变量的地址值赋给指针
   ip = &var;  /* store address of var in yiibaier variable*/
   NSLog(@"Address of var variable: %x
", &var  );
   /* address stored in yiibaier variable */
   NSLog(@"Address stored in ip variable: %x
", ip );
   /* access the value using the yiibaier */
   NSLog(@"Value of *ip variable: %d
", *ip );
   return 0;
}

栗子中ip指向的是var的地址值，所以它们值相等都是地址值，而*ip则指向的var的值，所以它们值相等是20

指针运算

OC的指针是一个地址，它也是一个数值，因此可以在数值上的指针执行算术运算。（++，-，+，–）

1
2
ptr++//指的是地址值的递增
ptr <= &var[Max -1] //地址值大小的比较
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
const int MAX = 3;
int main ()
{
//定义一个数组
   int  var[] = {10, 100, 200};
//定义一个指针和局部变量
   int  i, *ptr;
   /* let us have address of the first element in yiibaier */
   //指针指向数值的var[0]
   ptr = var;
   i = 0;
   //如果地址值小于数值最后一个数的地址值
   while ( ptr <= &var[MAX - 1] )
   {
      NSLog(@"Address of var[%d] = %x
", i, ptr );
      NSLog(@"Value of var[%d] = %d
", i, *ptr );
      /* yiibai to the previous location */
      //地址值++
      ptr++;
      i++;
   }
   return 0;
}

数组的指针

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#import <Foundation/Foundation.h>
 
const int MAX = 3;
 
int main ()
{
//定义一个数组
   int  var[] = {10, 100, 200};
//定义一个数组指针
   int i, *ptr[MAX];
 
   for ( i = 0; i < MAX; i++)
   {
   //遍历，将数组的地址值赋给数组指针
      ptr[i] = &var[i]; /* assign the address of integer. */
   }
   for ( i = 0; i < MAX; i++)
   {
   //遍历打印出数组指针每个地址对应的数值
      NSLog(@"Value of var[%d] = %d
", i, *ptr[i] );
   }
   return 0;
}

指向指针的指针

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#import <Foundation/Foundation.h>
 
int main ()
{
//定义一个变量
   int  var;
//定义一个指针
   int  *ptr;
//定义一个指向int类型指针的指针
   int  **pptr;
//赋值
   var = 3000;
//赋地址值
   /* take the address of var */
   ptr = &var;
   /* take the address of ptr using address of operator & */
//将int指针的地址值赋给pptr
   pptr = &ptr;
   /* take the value using pptr */
   NSLog(@"Value of var = %d
", var );
   NSLog(@"Value available at *ptr = %d
", *ptr );
   NSLog(@"Value available at **pptr = %d
", **pptr);
   return 0;
}

C语音的指针还是很强大的，虽然之前学过，但是感觉忘的都差不多了，再次重温，收获颇多。