// Playground - noun: a place where people can playimport UIKit// 几个重要的概念Properties/Methods/Subscripts/Initialization/Extensions/Protocols/Inheritance/Type Casting/Deinitialization/Automatic Reference Counting// 定义语法class someClass {    // 定义其它内容，如属性，方法，下标，初始化方法等等}// 属性 Properties// 存储属性class Person {    var name : String = "Anna"    var age : Int = 20}// 延迟存储属性[第一次使用时才进行初始化的属性，只能是var]class Dog {}class PersonContainsDog {    lazy var dog : Dog = Dog()}var pcd = PersonContainsDog()//pcd.dog 调用此行代码时才会去初始化dog属性// 计算属性class Square {    var width : Double = 0.0    var girth : Double {        get {            return width * 4        }                set {            width = newValue / 4 // 和OC类似，这里set有个默认参数newValue表示即将设置的值        }    }}var s = Square()s.girth = 20println("s width is \(s.width)")// 只读属性。对于只读计算属性，可以简写，直接return，不用写set，get关键字class Cuboid {    var width = 0.0, height = 0.0, depth = 0.0    var volume : Double {        return width * height * depth    }}// 属性监听器class PropertyObserver {    var count : Int {        willSet {            println("willSet:\(newValue)")        }                didSet {            println("didSet:\(oldValue)")        }    }        init() {        count = 1    }}class PropertyObserverSubclass: PropertyObserver {    override var count : Int {        willSet {            println("willSet:\(newValue)-sub")        }    }}var p = PropertyObserverSubclass()p.count = 2// 注意:1.提供了set方法时，无法再提供willSet，因为在set方法里便可以监听属性改变 2.willSet和didSet在属性初始化的过程中不会调用，只有当属性的值在初始化之外的地方被设置时才调用// 类属性 使用class声明的class SomeClass {    class var someClassProperty : Int {        return 20    }}// 方法// 实例方法：只能用对象实例调用的方法，也成为“对象方法” 对应OC中 “-” 开头的方法class Counter {    var count = 0    func increment() {        count++    }}var counter = Counter()counter.increment() // 通过实例变量调用// 方法的局部和外部参数 默认方法内的局部参数名也是外部参数名，相当于默认加 #class CounterBy {    var count = 0    func incrmentBy(amount: Int, numbersOfTimes: Int) {        count += amount * numbersOfTimes    }    // 下面的写法与上面一致//    func incrmentBy(amount: Int, #numbersOfTimes: Int) {//        count += amount * numbersOfTimes//    }    // 下面的写法为第一个参数生成外部变量名， 同时取消第二个参数的默认外部参数名 因为参数是方法的一部分，所以下面的方法与第一个方法是不同的，写在一起不会报错    func incrmentBy(#amount: Int, _ numbersOfTimes: Int) {        count += amount * numbersOfTimes    }        // 参数名作为方法的一部分，参数不同，方法不同. 所以此方法可以与第一个共存    func incrmentBy(amount: Int, someTimes: Int) {        count += amount * someTimes    }}var counterBy = CounterBy()counterBy.incrmentBy(3, numbersOfTimes: 4)counterBy.incrmentBy(amount: 3, 4)counterBy.incrmentBy(3, someTimes: 4)// 类型方法 使用class关键字修饰，可以直接通过类型调用class Calculator {    class func sum(num1: Int, num2: Int, num3: Int) -> Int {        return num1 + num2 + num3    }}Calculator.sum(1, num2: 2, num3: 3)// self 同OC中self一样. 在方法内部，self表示方法调用者本身，可以是实例，也可以是类// 附属脚本subscript// 基本用法 基本用法同方法，可以重载class someList {    var name = "someList"    subscript(index: Int) -> String{        return name + "\(index)"    }        subscript(prefix: String) ->String{        return prefix + name    }        subscript(num1: Int, num2: Int) -> Int {        return num1 + num2    }}var somelist = someList()somelist[10]somelist["hello, "]somelist[2, 6]// 继承 inheritance 与OC基本一致// 重写方法， 对重写的方法加override关键字class Animal {    var age = 3    func run() {        println("animal-->func run")    }}class Cat: Animal {    override func run() {        println("Dog-->override func run");        super.run()    }}// 重写属性 1、可以将存储属性重写为计算属性 2、可以将只读属性重写为读写属性 3、不可以将读写属性重写为只读属性class CatForAge : Animal {    override var age: Int {        set {            super.age = newValue * 2 // 注意不能使用self.age，会导致死循环。应调用super的set方法        }                get {            return super.age * 10 // 注意不能使用self.age 会导致死循环。应调用super的get方法        }    }}var cat = CatForAge()cat.age = 5cat.age// 重写属性观察 property observer 重写之后，仍会调用父类的willSet和didSetclass CatForPropertyOberver :Animal {    override var age: Int {        willSet {            println("CatForPropertyOberver-WillSet")        }                didSet {            println("CatForPropertyOberver-DidSet")        }    }}var catFPO = CatForPropertyOberver()catFPO.age = 4// 防止重写 final 使用final修饰的属性，方法，脚本无法被重写class CatForFinal : Animal {    final var name = "final" // 子类重写该属性时会报错。方法和脚本类似}// 构造 initialization 原则，保证所有的属性初始化完成// 1、没有默认值的存储属性，要在初始化过程中赋值 2、初始化过程中为属性赋值不会触发属性观察器 3、便利构造方法相当于对指定构造方法的封装 4、子类的指定构造方法默认会调用父类的无参指定构造方法class Color {    let red, green, blue: Double    init(red: Double, green: Double, blue: Double) {        self.red = red        self.green = green        self.blue = blue    }        convenience init(black: UIColor) {        self.init(red: 255.0, green: 255.0, blue: 255.0)    }}var c = Color(red: 255, green: 255, blue: 255)var anotherC = Color(black: UIColor.blackColor())// 析构 和dealloc一样. 主要用来释放资源，且不可主动调用class SomeObj {    deinit {        println("someobj dealloc or deinit")    }}