Swift3.0学习（二）

1、函数

有多个返回值的函数，可以用元组来实现

func getP() ->(Int, Double, String){
  return (1, 1.1, "abc")
}

使用注意

1. 省略外部参数

   //函数的每一个参数名：“xxx yyy: Int”，xxx是外部调用的参数名，yyy是内部的参数名，当xxx为_时，即省略外部参数名
   func add(_ num1:Int,_ num2:Int) -> (Int){
      return num1 + num2
   }  
   add(3, 5)
   

2. 默认参数

    //默认值
   //如果外界没有传递该参数，那么取默认值
   func addNum(num1:Int,dis:Int = 0)->Int{
       return num1 + dis
   }
   addNum(num1: 3)
   

3. 可变参数

   //可变参数
   //函数内部，把这个参数当做数组来出来
   func addNums(nums:Int...)->Int{//也可这样写func addNums(nums:[Int])->Int{
    //nums数组
    var result = 0
    for num in nums {
        result += num
    }
    return result
   }
   addNums(nums: [1,2,3,4])
   

4. 引用传递

   //Swift里用关键字inout代替了oc里的取地址符&
    func change(num :inout Int){
    num = 3
   }
   var a = 2
   change(num: &a)
   a
   

5. 编译器如何区分不同的函数
   与oc里只能靠函数名区别不同，Swift还可以靠另外两点
   1. 函数名（同oc）
   2. 参数名（外部参数）
   3. 函数类型（函数类型=参数类型+返回值类型）

2、枚举

//基本格式
enum Direction{
    case east
    case west
    case south
    case north
}
Direction.south

在Swift里面枚举类型默认情况下不表示任何类型，就是一个标识

//其他用法
enum Path:String{
    case cache = "user/desktop/cache"
    case download = "user/desktop/download"
    case music = "user/desktop/music"
}
//枚举值→原始值
let str = Path.cache.rawValue
//原始值→枚举值
let str2 = Path(rawValue:"user/desktop/music")

func testMyPath(path:Path){
    if path == .download {
        print(path.rawValue)
    }
}
testMyPath(path: .download)

3、结构体w

注意一点：结构体是值类型，在方法中传递是值传递

基本用法

struct Point{
    //实例属性
    var x: Double
    var y: Double
    //实例方法
    func distance(){
        print("计算两点之间的距离")
    }
    //类型属性
    static var z = 3.2
    //类型方法
    static func dis(){
        print("计算两点之间的距离")
    }
}
let s = Point(x: 2, y: 3)
s.distance()

Point.z
Point.dis()
//注：与oc不同，Swift的枚举，结构体都可以写方法

扩充构造函数

struct NewPoint{
    var x:Double
    var y:Double
    var z:Double
    //系统默认生成的构造器--“逐一构造器”，此构造器会保证创建的实例每个非可选属性都有值
    //自定义“构造函数”！=普通函数，一旦自定义则逐一构造器就没有了
    //不加func
    //必须使用init做为名称
    //在构造函数内部，必须要保证，所有的非可选属性，必须有值
    init(x:Double,y:Double) {
        self.x = x
        self.y = y
        z = 0
    }
}
let p = NewPoint(x: 1, y: 3)

4、类的基本使用

//Swift的类，是可以不继承父类的
class Person{
    var name: String
    //类默认情况下不会生成逐一构造器，但是一个类的实例被创建好后又必须保证所有非可选属性都有值，所以要自定义构造函数
    init(name:String) {
        self.name = name
    }
}

• 类可以用关键字deinit重写析构函数
• 类属性的可以单独重写getter方法，但不能单独重写setter方法
• 类里的类型方法除了用static修饰外还可以class来修饰，区别是后者子类可以重写前者不能
• 属性的监听

4、类和结构体的区别

• 结构体自带“逐一构造器”
• 结构体的值类型，类是引用
• 结构体不能继承（意味着没有多态），但是可以遵循协议（枚举也可以）、

5、any、anyobject和NSObject的区别

class Person: NSObject {
    
}
// public typealias Any = protocol<>
var array: [Any] = [1, "1", Person.self, Person()]

// 是一个协议内容为空的协议
// @objc public protocol AnyObject {}
var array2: [AnyObject] = [Person.self, Person()]


var array3: [NSObject] = [Person(), NSObject()]

6、可选链

class Person {
    var dog: Dog?
}

class Dog {
    var toy: Toy?
}

class Toy {
    var price: Int?
    func jump() {
        print("玩具跳")
    }
}

var p: Person? = Person()

var d: Dog? = Dog()

var t: Toy? = Toy()

p?.dog = d
d?.toy = t

//如果可选链的结果是nil，就代表调用失败（链条中间至少有一个环节断了）
//() == Void  != nil
p?.dog?.toy?.jump()


p?.dog?.toy?.price = 100
let price = p?.dog?.toy?.price ?? 0
//let p2 = p!.dog!.toy!.price!