//定义计算属性
/** [修饰符] var 计算属性名 ： 属性类型 { get{ //getter方法执行体，该方法必须有返回值 } set（形参名） { //setter方法执行体，该方法一定不能有返回值 } } 1，修饰符可省略 2.var: 只能定义成变量，因此只能使用var */
 //使用枚举定义一个计算属性
enum Season
{
    case Spring,Summer,Fall,Winter
    //setter，getter方法
    var info:String {
        //get
        get {
            println("正在执行getter方法")
            switch (self)
            {
            case .Spring:
                return "春暖花开"
            default :
                return "也就那回事吧~"
            }
        }
        //set
        set (newValue){
            println("正在执行setter方法，传入参数为：\(newValue)")
        }

    }
}
var s = Season.Spring //正在执行getter方法 //春暖花开
println(s.info) //正在执行setter方法，传入参数为：秋高气爽
s.info = "秋高气爽"
 //下一个例子
class User
{
    var first : String = ""
    var last :String = ""
    //定义计算属性
    var fullName : String
        {
        //定义计算属性的getter方法，该方法的返回值由first ，last两个存储属性决定
        get {
            return first + "-" + last
        }
        //set,负责改变该实例的first，last 两个存储属性 // set(newValue){ // //componentsSeparatedByString("-")通过“-”将字符串分割成数组 // var name = newValue.componentsSeparatedByString("-") // self.first = name[0] // self.last = name[1] // }
        //简化set方法,省略se的形参
        set{
            var name  = newValue.componentsSeparatedByString("-")
            self.first = name[0]
            self.last = name[1]
        }


    }

    init (first : String,last :String)
    {
        self.first = first
        self.last = last
    }
}

let m = User(first: "jiang",last: "jun")
println(m.fullName)//jiang-jun
m.fullName = "宇宇-芾"
println(m.first)//宇宇 //芾
println(m.last)
 //只读属性,省略get关键字，只读属性，不能被赋值，
class User1 {
    var first : String = ""
    var last : String = ""
    //定义只读属性，只有get方法
    var fullName : String {
        return first + "-" + last
    }
    init (first : String,last : String)
    {
        self.first = first
        self.last = last
    }
}

let q = User(first:"Jiang",last: "Jun")
println(q.fullName)//Jiang-Jun
 //属性观察者 //willSet(newValue):被观察的属性即将被赋值之前自动调用该方法 //didSet(oldValue):被观察的属性被赋值完成之后自动调用的方法
/* 属性观察者，可以监听如下属性变化 1.除了延迟存储属性之外的所有存储属性 2.可通过重载方式为继承得到的属性添加属性观察者 */
/* 语法： [修饰符] var 存储属性名 ：属性类型 [= 初始值] { willSet(newValue) { //属性被赋值之前自动执行的代码 } didSet(oldValue) { //属性被赋值完成之后自动执行的代码 } } */

class Person1 {
    //定义存储属性
    var name : String = "" {
        willSet{
            //用户名必须在2~6位之间
            if (count(newValue)>6) || (count(newValue) < 2)
            {
                println("您设置的人名\(newValue)不符合要求，请重新设置 ")
            }
            else
            {
                println("符合要求")
            }
        }
        didSet {
            println("人名设置完成，被修改的原名为：\(oldValue)")
        }
    }

    var age : Int = 0 {
        willSet {
            if newValue > 100 || newValue < 0
            {
                println("你的设置的年龄\(newValue)不符合要求，请重新设置！")
            }else{
                println("设置成功")
            }
        }
        didSet{
            println("年龄为：\(oldValue)")
        }
    }

}

var w = Person1()
w.age = 1000
w.age = 30
/* 你的设置的年龄1000不符合要求，请重新设置！ 年龄为：0 设置成功 年龄为：1000 30 */
println(w.age)

w.name = "jiangjun"
/* 您设置的人名jiangjun不符合要求，请重新设置 人名设置完成，被修改的原名为： jiangjun */
println(w.name)

w.name = "宇宇芾"
 //符合要求 人名设置完成，被修改的原名为：jiangjun 宇宇芾
println(w.name)

//将方法转成函数
class SomeClass
{
    func test()
    {
        println("执行test方法")
    }
    class func bar(#msg : String) {
    println("bar 类型方法，传人参数\(msg)")
    }
}
var sc = SomeClass()
//将sc的test方法分离成函数
var f1 : () ->() = sc.test
//将bar的类型方法分离成函数
var f2 :(String) ->() = SomeClass.bar
//以下代码等同
sc.test()
f1()
//以下代码等同
SomeClass.bar(msg: "测试信息")
f2("测试信息")

//方法的外部形参名，Swift会隐式添加

enum Gender
{
    case Male,Female
    //定义一个方法，并为给形参指定外部形参名
    func info(msg:String,count: Int,name: String)
    {
        for index in 1...count
        {
            println("\(msg)")
        }
    }
}

Gender.Male.info("text",count: 5,name: "JiangJun")

//值类型的可变方法
struct FkRect
{
    var x : Int
    var y : Int
    var width:Int
    var height: Int
    mutating func moveByX(x : Int,y : Int)
    {
        self.x += x
        self.y += y
    }
}
//创建FkRect实例
var rect = FkRect(x: 20,y: 23,width: 200,height: 200)
rect.moveByX(100,y: 80)
println("\(rect.x),\(rect.y)")//120,103

//可选链
//使用可选链代替强制解析
class Customer
{
    var name = ""
    var emp :Employee?
    init (name: String)
    {
        self.name = name
    }

    //使用可选链调用方法
    let employees = [
        Employee(name: "静静",title: "客服"),Employee(name: "文文",title: "售后")
    ]
    //该方法可根据员工名返回对应的员工，返回值为可选类型
    func findEmp (empName:String) ->Employee!
    {
        for emp in employees
        {
            if emp.name == empName{
                return emp
            }
        }
        return nil
    }
}

class Employee {
    var name = "Jiang"
    var title = "Jun"
    var company : Company!
    init (name:String,title:String)
    {
        self.name = name
        self.title = title
    }
}

class Company {
    var name = "上海"
    var addr = "嘉定"
    init(name:String,addr:String)
    {
        self.name = name
        self.addr = addr
    }
}
//如果Customer访问对应的公司的名称
var c = Customer(name: "宇宇")
var emp = Employee(name: "静静",title: "客服")
//设置Customer关联的Employee实例
c.emp = emp
//设置Employee关联Company
emp.company = Company(name: "新创公司",addr: "嘉定区，马路")
println("\(c.name),\(c.emp!.company.name)")//宇宇,新创公司

//使用可选链
var c2 = Customer(name: "宇宇")
c2.emp = Employee(name: "静静",title: "客服")
//可选访问属性
println("\(c2.name),\(c2.emp?.company?.name)")//宇宇,nil
//printlnprintln("\(c2.name),\(c2.emp!.company.name)")//报错


var c3 = Customer(name: "jiangjun")
println("\(c3.name),\(c3.emp?.company?.name)")//jiangjun,nil
//println("\(c3.name),\(c3.emp!.company.name)")//报错

enum Season
{
    static var desc : String?
    static let name = "季节"
    static var info : String {
        get {
            return "代表季节的枚举，其desc为：\(desc)"
        }
        set {
            println("程序尝试对info计算属性赋值：\(newValue)")
        }
    }
}
Season.desc = "季节类"
println(Season.name)//季节
Season.info = "新的info"
println(Season.info)//代表季节的枚举，其desc为：Optional("季节类")

本文部分内容来自《Swift疯狂讲义》