Swift相比OC语言有哪些优点
1、自动做类型推断

2、可以保证类型使用安全

Swif类型说明符
——Swift增加了Tuple表示元组类型

——Swift增加了Optional表示可选类型

常量一变量命名：
——可以用任何你喜欢的字符作为常量和变量名，包含Unicode 字符

——常量与变量名不能包含数学符号，箭头，保留的（或者非法的）Unicode 码位，连线与制表符

——不能以数字开头，但是可以在常量与变量名的其他地方包含数字

/*

\n —— 换行

\t —— 水平制表符 （4个空格）

\—— 表示1个\

"—— 表示1个"

'——表示1个'

*/

3.5e2 == 3.5乘以10的二次方

3.5e-3 == 3.5乘以10的-3次方

C的函数定义
         charname[10] ="China";

char address[10] = {'C','h','i','n','a','\0','B','e','i','\0'};

NSLog(@"%ld",strlen(name));//里面字符串的长度

NSLog(@"%ld",sizeof(address));

//包含\0的长度（自己定义字符串长度后会使用调用后的长度）

charsex[] ="nan";

NSLog(@"%c",sex[2]);

Swift
在Swift中要想越界

num = num &+ 1(溢出运算)

var str1 = "China"

var str2 = str1 + "Beijing"

str1 += "Beijing"

9 % 4  //  等于1

9 % -4  //  等于1

-9 % 4  //  等于-1

-9 % -4  //  等于-1

BOOL类型比较
只能使用 == 或者 ！=   不可以使用  >、<、>=、<=

当俩个元组中的数据类型及顺序完全匹配时，可以使用比较运算符比较

如果元组包含Bool类型，只能使用==和!=比较，不可以使用>、<、>=、<=

Swift 标准库只能比较七个以内元素的元组比较函数。如果你的元组元素超过七个时，你需要自己实现比较运算符。

空合运算符（只适用于可选类型）
形式：a ?? b

对可选类型 a 进行空判断，如果 a 包含一个值就进行解封，否则就返回一个值 b

表达式 a 必须是 Optional 类型

默认值 b 的类型必须要和 a 储存值的类型保持一致

区间运算符
1、闭区间

a...b定义一个包含从 a 到 b （包含 a 和 b ）的所有值的区间

a 的值不能超过 b

2、半开区间

a ..< b 定义一个包含从 a 到 b（不包含b）的所有值的区间

a 的值不能超过 b

3、自增自减运算符在Swift中不能用

++a (前增)         a++ (后增)        --a (前减) a-- (后减)

//使用索引值
var name = "yangyingqiu"        (后面会自定添加\0)

var index = name.startIndex //得到字符“Y”的索引值

index  = name.endIndex  //得到最后位置的索引值，比最后一个字符“g”的位置打1

index = name.index(after: name.startIndex) //获取起始位置之后的索引值

index = name.index(before: name.endIndex)  //获取最后位置之前的索引值

index = name.index(name.startIndex, offsetBy:3) //

index = name.index(name.endIndex, offsetBy:-4) //

print(name[index])

遍历字符串中的每个字符
//for in循环

for item in name {

print(item, terminator:"")

}

print()

//while循环

var offset = 0

while offset < name.count {

let index = name.index(name.startIndex, offsetBy: offset)

//(let index:String.Index = name.index(name.startIndex, offsetBy: offset))

print(name[index])

offset += 1

}

//遍历字符串的所有索引值，从而遍历每个字符

for myIndex in name.indices {

print(name[myIndex])

}

可选绑定语法
if let item = a {

print{item}

}

//遍历语法
for var item in1...5   {      //如果不加var默认为let

print{item}

}

let base = 3

let power = 10

var answer = 1

//如果在循环体中不需要循环变量的值，可以使用下划线代替变量的名称

for _ in 1...power {

answer * = base

}

Switch语句中可以加 int char string 枚举 double（后面必须加default）如果想满足多个条件打印同一个结果可以用“，”来隔开
var ch = 3

switch ch {

case 10:

print("不讲价")

case 7...9:

print("(ch)折")

default :

print ("不可能")

} //可以添加元组类型的数据

给循环添加 标签

outer: for I in 1...3 {

inner:for j in 1...5{

break outer

}

print("I = (i),j = (j)")

}

//Swift中，Struct，Double，String、数组、字典、都是值类型
//swift中，类、函数、闭包都是引用类型
//如果结构体中的s已经是常量，里面的成员变量和结构体本身就不可以重新赋值了
//如果类中的s是常量，里面的成员变量可以重新赋值变量，不能重新赋值常量
//、在swift中 == 号只能用在值类型不能用在引用类型（== 在自定义的结构体中自定义的类中也不可以用）
//Swift中 === (恒等于)  !==(恒不等于)只能用于引用类型，不能用于值类型，判断俩个对象指向同一个内存空间（判断地址）
//在结构体中，必须讲方法声明为可变的，才可以在方法体中改变属性的值
//在类中可以直接改变属性的值
重写set、get方法的时候方法里面不能出现sum属性本省否则出现死循环、

如果没有加set、get就会默认重写get语句,get中有俩个语句的话就必须添加get方法

lazy起到延迟加载作用，在调用的时候使用

//便利构造器（如果在某个构造器中调用其他的构造器，须要将构造器做成便利构造器）

指定构造器与便利构造器的区别：

默认构造器是系统提供的构造器

指定构造器是类中主要的构造器，一个指定构造器将初始化类中所提供的所有属性

便利构造器是类中次要的、辅助型的构造器，可以定义便利构造器来调用同一个类中的指定构造器

//子类可以继承父类中所有的属性和方法，子类可以有自己独有的属性和方法

//子类可以重写父类中的方法

你可以将一个继承来的只读属性重写为一个读写属性，只需要在重写版本的属性里提供，getter 和setter 即可，但是，你可以将一个继承来的读写属性重写为一个只读属性

循环强引用问题（retain cycle），在俩个类中互相包含对方的对象做成自己的属性会发生循环强引用

解决：1、使用弱引用，用一个weak来修饰

2、unowned（不能使用引用类型，只能使用基本类型）

thows:一般用于方法定义的按返回值之前，表好似将该方法做成一个可抛出错误的方法（throwing）

Thow:一般用于方法体内，抛出某个具体的错误，如果能执行throw，后续语句都不会执行，该方法调用立即结束，等效return语句

Ios  多态

不同类中有相同方法，调用的时候互不影响

父类指针指向子类，调用一个被重写的方法，父类指针调用这个方法呈现的都是子类中方法的定义执行

扩展

//var name:String = ""(在扩展中不可以扩展存储属性)

//可以扩展“计算属性”

//可以扩展“只读属性”

//存储类型的类属性

//计算类型的类属性

//只读类型的类属性

//添加对象方法

//添加类方法

//在扩展中只能为类添加便利构造器，不可以添加指定构造器