swift3.0基础语法，2

1.Hello Word

2.基础语法

3.构造器、析构方法

4.扩展、协议

变量/常量，元组声明

var  aaa = 0;//声明变量aaa 首次赋值时自动解析为Int类型
var aaa:Int = 0;//声明Int类型变量aaa
let aaa = 0;//声明常量aaa 首次赋值时自动解析为Int类型，常量值不可被修改 
let aaa:Int = 0;//声明Int类型常量aaa ，常量值不可被修改

在swift中 除了简单的数据类型外，还有高级的数据类型（类，函数，结构，元组等等），其中比较有趣儿的是元组类型，因为其在代码的可读性与自由度上都很舒适，下面进行简单的元组数据声明。

/*
*声明元组变量/常量
*/
var/let   aaa = (值0，值1，值2，值3...);
aaa.0;//值0
aaa.1;//值1
aaa.2;//值2
var/let   (a,b,c,d...) = (值0，值1，值2，值3...);//一一对应
a;//值0
b;//值1
c;//值2

类型别名

类型别名就是为了现有类型定义的替代名称。

typealias 类型别名 = 数据类型名称

typealias  myInt = int;//声明myInt 赋值为int类型
var maxInt = myInt.max;//声明变量maxInt  和int.max等价
maxInt;// int.max

运算符

&：按位与
|：按位或
^:按位异或
~：取反
<<：左移
>>：右移
&+：溢出加法
&-：溢出减法
&*：溢出乘法
<:小于
<=:小等于
>:大于
>=:大等于
==:等于
!=:不等于
&&：逻辑与
||：逻辑或
！：逻辑非
*=：乘后赋值
/=:除后赋值
%=:取余后赋值
+=:加后赋值
-=:减后赋值
<<=:左位移后赋值
>>=:右位移后赋值
&=:按位与后赋值
^=:按位异或后赋值
|=:按位或后赋值
??:空和运算
?::三目运算

数据类型

1.数组

let/var intArray:[Int] = [];

2.字典

var/let dic = [key:value,key1:value1,key2:value2...];

3.集合

let/var letters:Set<Character> = ["A","B","C"];

注意：类型声明时，其可变或不可变使用var和let进行区分。使用let声明为不可变集合，其长度是不能被改变的，在字典中，不可变意味着不能替换已经存在的键的值，但和数组不可变有些不同，字典可以修改其值，数组值不可修改。

流程控制

1.if...else if...else...

var a:Int = 0;
var b:Int = 1;
if a==b{
    print("a和b相同");      
}else if b>a {
    print("b大于a");
}else{
    print("b小于a");
}

2.switch

var a:Int = 20;
switch (a){
    case 5:
        print("a==5");
    case 20:
        print("a==20");
    default:
        print("前面条件都不符合");  
}

3.for...in...

var a = [1,2,3,4,5...];
for x in a{
    print("\(x)");  
}

4.repeat while...

repeat{
    a/=10;
    print("a is \(a)");
} while a!=0

函数和闭包

1.函数

//若想调用有参函数，想将参数名省略 可以在定义参数时前面加上"_"
func 函数名(_参数名1：数据类型 = 默认值1，参数名2：参数类型 = 默认值2...)->返回值类型/（返回值1：返回值类型1，返回值2：返回值类型2...）{
    //函数体
    return 返回值类型参数/（返回值类型1参数，返回值类型2参数...）
}

//可变参数函数
func 函数名1(numbers:Int...)->返回值类型{
    //函数体
}
//可变参数调用
函数名1(1,2,3,4,5,6);

//输入输出参数
var a:Int = 2;
func changeA(lastA:inout Int){
    lastA = 4;
}
print("\(a)");  //a = 2
changA(lastA:&a);
print("\(a)"); //a = 4

//方法作为参数或返回值
func 函数名(参数名:(参数类型1，参数类型2...)->返回值类型)->(参数类型1，参数类型2...)->返回值类型{
 //函数体 
}

2.闭包

var/let v1 = {(参数1：参数类型，参数2：参数类型...)->返回值 in
    return 返回值类型参数；
}
var/let v1 = {
    //$0,$1,$2...来表示参数 省略    
    //N个参数的操作
}

下标脚本

subscript(变量:类型)->返回值类型{
    return 返回值;
}

下标脚本一般应用于一些功能性的辅助，如方法下标 方法名(参数)[0] 这样的灵活性调用。

类型检查

1.is

实例 is 子类型

is关键字可以用来检查一个实例/对象的所属类型。

"i am superman" is String //true

2.as/as?

实例 as 类型

as/as? 就是用来强制转换形式的关键字，当转换一定成功时才可以使用强制转换形式的检查。

var lib = ["123",12];
for l in lib{
    var a:Int = l as Int;  
}

枚举

enum 枚举名称:枚举类型{
    case  变量 = 值;
    //枚举属性
    var reNum:Int{
        return 10;
    }
    static var reNum1:Int{
        return 100;
    }
    func 方法名(参数)->返回值类型{
        self；//self为当前枚举中的某一成员对象
        return 返回值;
    }

//....  }
枚举名称.变量.rawValue；//访问变量原始值
枚举名称.变量.reNum; //10
枚举名称.reNum1；//100
枚举名称.方法名();//执行 方法名 方法

枚举类型在程序的诸多设计中存在关键的逻辑作用，可以让代码更加的符合面向对象规则，是一种逻辑上理解的应用，但本人觉得，如果会用的会觉得枚举的重要及舒适，如果不会用的 程序依然会跑，但其设计和很多方面的逻辑灵活都不如前者。

枚举间可进行灵活的嵌套，如数组。

注： 当枚举类型为Int时，如未指定变量值，则第一个以0开始依次递增，如第一个指定值 之后的没有指定，则以第一个值开始，依次递增。