学习目标

由于已经有了Java编程思想，所以着重了解Swift语言特有的特性，与Java不一样的地方。最终目的是可以使用Swift语言开发iOS应用。

学习过程

• [阅读苹果官网Swift文档]（https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/TheBasics.html)
• 使用Xcode动手尝试运行部分代码。
• 文档总结

学习内容

The Basics [Swift概览]

• Swfit是类型安全的语言。变量的类型是确定的。不同于PHP，PHP类型是不确定的。

• Swift结束不用添加分号;，这点与Java不同。

• 数据类型。Swift的基础数据类型有表示整型的Int,表示浮点型的Double和Float，表示布尔值的Bool，表示字符串的String。集合类型有标识数组的Array,表示无序集合的Set,表示映射关系的Dictionary。Swfit还提供自己特有的类型:元组.元组没有具体的关键字，表达形式是(value1,valule2...);

• 声明方式。Swift的声明方式只有两种，通过关键字 let和var。这点区别与Java的变量声明。let声明的变量类似于Java通过final声明的变量，不可修改。var声明的变量可以被修改。声明的变量,使用前必须初始化（可选类型除外）。下面是变量max的几种声明方式：

  let max = 10; //明确了 max的类型是Int.
  let max :Int ://同样明确了max的类型是Int.因为这里没有确定初始值，所以使用前必须赋值，否则会报错。
  var max = 10//max可以改变成其他值，而let声明的就不可以。
  

• 在字符串中连接变量值可以通过 (变量名称)方式。例如

  let name = "Zhouztashin";
  NSLog("my name is \(name)");
  

• Int类型区分。Swift语言，Int类型同样有有符号和无符号的区分和位数的区分。一般，我们使用Int就可以了，当前平台是32位，它就是32(Int32)的。无符号的Int类型U开头，例如UInt32。

• Double表示64位的浮点数，Float表示32位的浮点数。

• 类型别名。Swift提供类型别名的机制，提高代码可阅读性。使用关键字 typealias可以为类型指定别名：

  typealias AudioSample= UInt16;//为UInt16指定别名。
  

• 可选概念。Swfit里面有一个"Optionals"概念。例如某个变量可以有值，也可以没有值。这就是可选的概念。没有值使用nil表示。使用？符号声明的变量就是可选变量,可选变量可以被赋值为nil。非可选变量不能为nil。

• 可选概念使用方式。Swfit提供了一种可选概念的使用方式：

  //语法
   if let 变量名  = 可选语句{
  //如果赋值最终不等于nil 则执行这里的语句
  }else{
  //赋值等于nil ，则执行这里。
  }
  

  //例子
  //强制转换 字符串 "not Number"为Int，结果是失败，所以number =nil;
  if let number = Int("not Number"){
  //由于number=nil,所以这里不会被执行
  }
  

• Swfit也提供了异常处理机制，类似于Java的异常处理机制。

Basic Operators [Swfit 操作符]

• 各类操作符与Java是一致的。
• 操作符号的左右两边要留出空格，不然会报错。
• nil值操作符。Swfit提供了??操作符。

  let valueA = "A";
  var valueB: String?
  var result = valueB ?? valueA; //如果valueB 为nil，那么就将valueA的值给result.
  

• 范围操作符。Swfit提供范围操作符号"a...b".指定了 从a到b。

  for index in 1...5{
  //这里循环5次，从1到5。
  }
  

• 半开范围操作符。Swift提供了半开操作符 "a..<b",类似于范围操作符。

  for index in 0..<10{
  //循环10次，从0到9.
  }
  

Strings and Characters [字符和字符串]

• 字符串声明方式。

  var emptySting = "";
  var anotherEmptyString = String();
  

• 字符声明方式。

  let singleChar : Character;
  

• 字符串是值类型。不是引用类型。这一点需要与Java区分。
• 字符串拼接。字符串拼接可以通过"+";
• 可以通过 (变量)方法在字符串里面嵌入变量值。例如

  let name = "Zhouztashin";
  print("My name is \(name)");//会打印出 My name is Zhouztashin。
  

• Swift提供了判断是否有相同前后缀的功能。例如。

  let str1 = "LiXX";
  let str2 = "ssLi";
  

• Swfit提供了Unicode的访问形式。"\u{代号}"
• 常用方法。

  var name = "Zhouztashin";
  1、name.isEmpty  //空判断
  2、for character in name.characters{//遍历打印字符
        print(character);//打印单个字符
  }
  3、name.count;//获取字符串数量
  4、name[index];//获取某个下标位置的字符
  5、name.insert("My name is",at :0);//在下标0的位置插入字符串。
  6、name.remove(at :0);//移除下标为0的字符。
  7、name.hasPrefix("Zhou") // 前缀判断，因为有前缀Zhou,所以结果为true;
  8、name.hasSuffic("shin")//因为有后缀shin,所以结果为true;
  

Collection Types [集合]

• 集合数据类型。Swift提供了三种集合的数据类型。Array,Set,Dictionary。其中Array类比于Java的列表和数组，Set类比Java的Set,Dictionary类比Java的Map。
• 集合可变与不可变。不同于Java语言，因为Swift集合类型是值类型，所以，Swfif的集合类型如果被声明为let的话，该集合本身和其包括的数据均不能变动。
• 集合元素访问&赋值方式。Array可以通过数字下标方式访问和赋值，Set则需要通过特定的SetIndex<>下标访问。Dictionary可以通过Key以下标的方式访问相应值。
• 集合通用方法。空判断(isEmpty)和获取数量(count)的方法是通用的。
• Array声明方式:

  var someInts :Array<Int>;//声明一个未初始化的Int 列表类型。
  var someInts :[Int];//简约声明方式。
  var someInts = [Int]();//简约初始化空方式。
  var someInts = [];//当someInts已声明了具体类型，那么可以通过[]将该列表置为空
  var someInts  = [12,23];//简约初始化赋值方式。
  var threeDoubles = Array(repeating :0,0,count:3);//特定声明方式，结果会生成 [0,0,0,0,0,0];
  

• Array常用方法。与第2节字符串操作所用的方法是一样的。
• Array遍历方式:

  var someInts = [1,2,3];
  1)、遍历元素
  for item in someInts{
  print(item);//打印1，2，3
  }
  2)、遍历下标和元素
  for (index, value) in someInts.enumerated(){
  print("\(index) AND \(value)");
  }
  

• Set声明方式:

  var someInts :Set<Int>;//声明一个未初始化的Int 列表类型。
  var someInts :Set = [Int]();//简约初始化空方式。
  var someInts = [];//当someInts已声明了具体类型，那么可以通过[]将该列表置为空
  var someInts :Set = [12,23];//简约初始化赋值方式。
  

• Set常用方法。与第2节字符串操作所用的方法是一样的。
• Set遍历方式。与Array类似。
• Dictionary声明方式:
  var someDictionary = String : String;//声明一个字符串与字符串的映射字典。
  var someDictionary :[String : String];
  var someDictionary = ["Zhou":"ZeXuan","Zhong":"Hong"];//以:符号分割键值对。
  var simeDictionary = [:];//将该字典变量置为空。
• Dictionary常用方法:

  var someDictionary = ["Zhou":"ZeXuan","Zhong":"Hong"];
  1)、更新键值对。[也可以通过下标方式]
  someDictionary.updateValue("Yong",forKey:"Zhong");//更新键为Zhong的值为 "Yong";
  2)、移除键值对。
  someDictionary.removeValue(forKey:"Zhong");//移除键为Zhong的键值对。
  

• Dictionary 遍历方式:

  var someDictionary = ["Zhou":"ZeXuan","Zhong":"Hong"];
  //遍历获取键值对
  for (key,value) in someDictionary{
  print("\(key),\(value)");//打印出 Zhou,ZeXuan。Zhong,Hong。
  }
  //遍历键。
  for key in somDictionary.keys{
  print(key);//打印键。
  }
  //遍历值
  for value in someDictionary.values{
  print(value);//打印值
  }
  

• 获取键值对列表。通过 let keys = [String] ta(someDictionary.keys) 获取键列表。值也一样，不过把调用的方法从keys改为values。

Control Flow [控制流程]

• Swift提供了的判断流程、循环流程，选择流程。这里仅列出常用的使用方式。

• Swift提供了continue,return,break跳出当前控制流程。与Java一致。

• 判断流程。与Java类似，采用if else关键字。不同的是不需要使用()将条件包括起来。

  //语法格式
  if  条件 {
  }else{
  }
  //例子
  var year = 1;
  if year == 1 {
  print("我一岁");//打印此语句.
  } else{
  }
  

• 选择流程。选择流程也与Java类似，采用switch cas关键字。不同的是Swift的switch不需要break;语句跳出当前匹配代码段。如果需要延续下面匹配值的代码段，则需要使用fallthrough语句，只会延续一个匹配值。

  //语法格式。
  switch 值 {
  case 值1:
  执行代码段;
  case 值..:
  执行代码段;
  default:
  未匹配到则执行这里。
  }
  //例子：
  var year  =1;
  switch year{
  case 1:
      print("我1岁");
  case 2:
  print("我两岁");
  }
  //结果是打印 我1岁；
  

• 循环流程。Swift同样提供了for 跟while 循环语句。while语句与Java一致。这里只说for语句

  //语法格式
  for 变量  in 范围{
  }
  //其中范围采用了Swfit特有的范围操作符。
  //例子
  for index in 1...10{
  print(index);//打印1到10.如果需要只打印1到9，那么应该使用  1...<10。
  }
  

• Swfit提供了简约的变量赋值语句。使用了关键字guard。

  //例子
  guard let name = Int("Zhou") else{
  //赋值不成功则执行这里。
  }
  

Functions [方法]

• Swift方法声明与调用方式。Swift的调用方式与Java有一些区别，Swfit调用方法需要指定相应的参数名称。

  //声明格式。
  func 方法名 (参数名:参数类型,...) ->返回值类型{
  return;
  }
  //例子。
  func isNumber2(number : Int) ->Bool{
  if number ==2 {
  return true;
  }else{
  return false;
  }
  }
  //调用
  let is2 = isNumber2(number: 2);//调用的时候需要指定参数名称。
  print(is2);//输出true;
  

• 调用方法不需要输入参数名称的方式。通过在参数名称前面添加 "_"符号就可以在调用的时候不指定参数名称。例如

  //调用时：isNumber2(2);//由于声明的时候参数添加了 "_"，所以不需要参数名称。
   func isNumber2(_ number :Int) ->Bool{ ...}
  

• 默认参数值。可以为参数指定默认值。通过在声明的时候赋值，就可以为参数添加默认值。

  //为参数number添加了默认值 3，调用的时候可以不用传入该参数值。
  func isNumber2 (number :Int = 3) ->Bool{...}
  

• 可变的参数值。可以为不指定参数的数量。声明的时候添加"...".例如：

  //可变的参数声明。调用的时候可以传入不等长度的参数。例如 isNumber2(12.3,34.4); isNumber2(12.4);
  func isNumber2(number : Double ...)->Bool{};
  

• in-out 参数方式。类似于C语言中的引用传递。由于Swift Int等基本类型是值类型，所以在方法中改变该值只在该方法范围内有效。而通过指定参数为inout类型，那么就会影响到方法外该变量的值。
• 方法也可以是一个变量参数。Swift提供了一个特性，方法也可以是一个变量或者参数。

Closures [闭包]

• 闭包的应用之一，参数为方法的时候的简约调用方式。

  //语法
  {
  (参数) -> 返回值  in
  代码段
  }
  //例子
  let array  = ["Str1","Str2"];
  array.sorted(by: {(s1:String,s2:String)->Bool in return s1>s2});
  //更简约的方式
  array.sorted(by :{ s1,s2 in return s1 >s2});//因为参数和返回值是确定的所以不用再描述。
  

Enumerations [枚举]

• Swift提供的枚举类型跟Java类似。但是比Java要更加好用些，例如Swfit可以给枚举项直接添加对应值。

  //语法。
  enum 枚举名称{
  case 枚举项
  case 枚举项2
  }
  或者
  enum 枚举名称{
  case 枚举项1，枚举项2，枚举项3..
  }
  //例子
  enum CompassPoint{
  case north
  case south
  case east
  case west
  }
  //引用方式
  var directionTohead = CompassPoint.north;
  directionTohead = .east;//因为变量指定了CompassPoint类型，所以可以用这种简约的赋值方式。
  

• Swfit提供给枚举类型添加相应的值。

  //语法
  enum 枚举名称 : 值类型{
  case 枚举项 = 值；
  case ..
  }
  //例子
  enum Planet : Int{
  case mercury  = 1, venus;//mercury 对应的值为 1;
  }
  //引用方式
  let mercuryValue = Planet.mercury.rawValue;//通过关键字rawValue获取值。
  

• 可以通过枚举类的值获取对应的枚举项。

  let somePlanet = Planet (rawValue : 1);//这里查找值为1的枚举项，结果为mercury。
  

Classes and Structures [类和结构体]

• Swift提供了两种块结构。类和结构体。类与结构体的结构和作用是类似的，只不过在不同的应用场景下需要选择相应的结构。这两者跟Java的类是类似的，都由成员变量，成员方法构成。但是区别于Java的是类的文件名称跟里面实际声明的类的名称并不需要一致。
• 声明方式和实例化方式

  //声明方式
  1) struct 结构体名称{ //结构体声明方式
  //变量
  //方法
  }
  2） class 类名称{ //类声明方式
  //变量
  //方法
  }
  //实例化 
  struct Circle {
  var width :Int;
  var height :Int;
  }
  let circle = Circle();//实例化类或者结构体
  

• 类和结构体的区别。
  1)、类是引用类型。而结构体和枚举类是值类型。
  2）、结构体倾向用于封装一些简单的数据。
  3）、类可以继承，而结构体无法被继承。
  4）、类和结构体的存储成员变量（区别与计算变量）需要在声明或者在构造函数中被初始化，否则会报错。如果有一个存储成员变量没有初始，那么在实例化的时候需要通过这个全量结构函数传入所有值，否则会报错。类和结构体默认添加了一个全量的初始化方法。
• 判断类指向同一个实例。通过“===”和“!==”判断两个变量是否引向同一个实例。
• Swift的String、Array、Dictionary、Set都是结构体，所以他们都是值类型。

Properties [属性/成员变量]

• Swfit将属性按照作用分为两类，一类是存储变量，一类是计算变量，这与Java的成员变量区别很大的一点。另外跟Java一样，Swift也有成员变量和类变量的区分，一样使用static 修饰词。
• 存储变量与Java的成员变量是一致的。计算变量的声明方式

  struct Point{
  var x = 0,0,y = 0.0;
  }
  struct Rect{
  var origin = Point();
  var center :Point{ //center则是Swift语法中的计算变量。重新定义了获取和赋值的操作。
  get{
  return Point(x :2.2,y:23.3);
  }
  //如果没有写newCenter，那么默认设置的变量名是newValue，如果没有写set方法，就说明该计算变量只可读。
  set(newCenter){ 
  origin.x = 2;
  origin.y = 3;
  }
  }
  }
  

• Swift成员变量调用方式。

  struct Point{
  var x = 0.0,y = 0.0;
  }
  var point = Point();
  let x = point.x;//获取成员变量x的值。
  point.x = 1.3;//更改成员变量x的值。
  

• 成员变量观察者。成员变量支持赋值改变前后的观察通知。通过willSet 和 didSet方法可以得知成员变量被改变的前后。

  //语法
  class 名称｛
  var 变量 :类型{
      willSet(新的变量值名称){ //改变值前的回调
        //
        }
      didSet{//改变值后的回调
       }
    }
  }
  

Methods [方法]

• 方法类型。Swift中的方法跟Java一样也分为实例方法和类方法。跟Java一样，类方法也是通过添加static修饰词。
• 关键字 self.self代表结构体、类本身。与Java的this关键字相似。
• 方法内改变成员变量值。在结构体或者枚举类里面不可以直接改变成员变量值，需要使用关键字 mutating修饰方法才可以修改成员变量。

Inheritance [继承]

• Swift中的类可以被继承。跟Java一样，也支持多态。

  //语法
   class 名称 : 父类名称{
  // 
  }
  //例子
   class Father {
   }
  class Son : Father{
  }
  

• 重写方法。Swift一样可以重写父类的方法。通过关键字override。
• 调用父类的方法和成员变量。通过关键字super可以调用父类的方法和成员变量。
• 重写成员变量。不但可以重写方法，Swift也可以重写成员变量的方法和观察者。

  //例子
  class 类名称{
        override var current :Double{ //重写的时候需要重新声明变量。
            didSet{
            //
            }
        }
  }
  

• 同样，通过final 声明可以防止重写。

Initalizers [初始化]

• 初始化类似于Java的构造函数。与Java用类名表示构造函数不同的是，Swift通过 init表示构造函数。
• Swift将构造函数分为了两类，一类是Designated 初始化方法 和Convenience初始化方法。其中Designated就是Java中的构造函数，Convenience就是Swift对外调用提供的简约式声明方式，convenidence修饰的构造方法必须调用Designated 方法。这样重载简约的构造方法的逻辑会清晰很多，因为一定会调用普通的构造方法。
• Swift还提供可选式样的构造函数，类似于Option值。

Deinitialization [析构函数]

• 类似与Java类中的finalize函数。当该类实例被回收的时候就会调用该方法。方法的声明方式：

  deinit{
  //处理代码
  }
  

Automatic Reference Counting [自动引用计数器]

• Swift也跟Java一样也有对引用的自动回收机制。
• Swift引用计数原理。Swift的引用计数系统会跟踪属性、常量、变量对类实例的引用，如果有存在一个引用以上，则不销毁该实例。
• 强引用循环问题。Swfit会出现强引用循环的问题，就是类实例A引用了类实例B，两者相互引用。Swift提供的解决方案是使用weak修饰符让变量成为弱引用。与Java的弱引用同出一辙。

Error Handing [异常处理]

• Swift同样提供了异常处理的机制。跟Java的异常机制类似。

  1)、抛出异常.
  func throwsException () throws {
  throw 异常信息
  }
  2)、不处理异常，继续抛出异常
  func throwsExceptionGoOn ()throws{
  try throwsException();
  }
  3)、处理异常。
  func handleException(){
        do
        {
        try throwsException();//这里可能抛出异常 
        }catch(){//匹配异常
        //处理异常。
        }catch(){
        //处理异常2
      }
  }
  

• Java有finally{}模块可以确保一些结束操作可以被执行，而Swift也提供了类似的机制，通过defer关键字可以确保里面的代码段在最后被执行。需要注意的是defer句子应该在异常代码之前被声明。并且会先于catch模块前执行。

  func processFile(filename : String) trhows{
  let file open(filename);
  defer{ //这里的代码段会在该范围内所有代码都执行完毕才执行。
    close(filename);//执行关闭操作。
    }
  }
  

Type Casting [类型转换]

• Swift提供了两种类型转换相关的语法。一种是判断，一种是转换。通过 is 关键字可以判断某个变量是否是某种类型，通过 as? 和 as!转换类型。is类似与Java InstanceOf的关键字，as类似与Java中的强制转换()。

  1) 、is。判断某个变量是否是某种类型或者某种类型的子类。
  class Animal{
  }
  let animal = Animal():
  if(animal is Animal){
  //这里会执行。
  }
  2)、as? 和as! 可以将类型转换为某种类型。
  class Animal {
  }
  class People : Animal{
  
  }
  let people = People();
  let asAnimal = people as? Animal;//现在asAnimal 是 Animal类型了
  

• Swift提供了两种任意类型。Any 和AnyObject。其中可以将任何类型的变量转为Any,包括方法。而AnyObject可以代表任意一个类实例。其中AnyObject类似与Java的基类Object.

Extensions[扩展]

• 扩展是Swift提供的新特性。可以为类、结构体、枚举类、协议扩展新的功能，不同于继承，扩展没有继承层级上的关系。可以当作是附加衍生。
• 可扩展的内容：
  1)、计算性成员变量。
  2)、实例方法与类型方法
  3)、新构造方法
  4)、下标
  5)、实现协议
• 扩展语法。

  1)、extension SomeType : Protocol1,Protocol2{
  //添加扩展内容
  }
  2)、实例。为Double添加类型扩展。
  extension Double{
  var km:Double{return self* 1000_0.0}//
  }
  let onInch = 25.6.km;//km是新扩展的计算成员变量。
  

Protocols[协议]

• 协议与Java中接口的概念是一致的。Swift协议中定义了包括方法、成员变量、类型变量的蓝图。与Java接口不同的是，协议不但可以定义方法，还可以定义成员变量。
• 协议声明与实现:

  //协议语法
   protocol Nametocol : class{.//如果添加了 class关键字，说明该协议只可以被类实现。
      var fullName :String {get }
      statc func someType();//类型变量，也就是Java的静态变量
      func someMethod();
      mutating func toggle();//可更改内部变量值的方法
      init()//初始化方法
     //可选实现。通过添加@objct optional 关键字修饰，     该方法可以不实现。
      @objc optional func optionalMethod();
  }
  `
  //协议实现
  class MyName :NameProtocol{
  //这里需要实现协议包含的所有内容，区分与Java这里的方法实现不需要添加override关键字
  }
  

Generics [泛型]

• Swift也提供了泛型，与Java泛型相似。

Access Control [访问控制]

• Swift也提供了访问控制功能。有模块和文件两类访问控制。
• 导入模块。通过import 关键字可以导入并使用该模块功能。与Java类似。
• Swift提供了四种等级的访问控制。分别是public ,internal,fileprivate,private。
  • public.public定义的实体可以在自己的模块内被访问，另外其他模块如果导入了该模块，那么其他模块也可以访问该实体。
• internal.internal定义的实体可以在自己的模块内被访问。
• fileprivate。fileprivate定义的实体只能在该文件内被访问。
• private.private定义的实体只能在该实体里面被访问。
• Swift访问控制规则：一个被定义为低访问控制的实体，不能声明为高访问控制等级的任何实例。实体包括变量方法等。。
  • 例如定义了一个internal等级的ClassA,不能被声明为 public let classA :ClassA.
  • 一个方法的参数和返回值类型定义的访问权限，一定要大于或者等于该方法被声明时候的权限控制等级。
  • 跟Java一样，继承后重写的方法不能比父类的方法控制权限大。
• Swift默认为每个实体添加了访问控制：internal.