Swift-9-类和结构体

// Playground - noun: a place where people can play

import 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 = 20
println("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 = 5
cat.age

// 重写属性观察 property observer 重写之后，仍会调用父类的willSet和didSet
class 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")
    }
}