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")

    }

}