Swift learn 7

Swift 析构函数&扩展

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

import UIKit

//析构函数的使用
struct Bank {
    static var coinsInBank = 10_000
    static func vendCoins(var numberOfCoinsToVend: Int) -> Int {
        numberOfCoinsToVend = min(numberOfCoinsToVend, coinsInBank)
        coinsInBank -= numberOfCoinsToVend
        return numberOfCoinsToVend
    }
    static func receiveCoins(coins: Int) {
        coinsInBank += coins
    }
}

class Player {
    var coinsInPurse: Int
    init(coins: Int) {
        coinsInPurse = Bank.vendCoins(coins)
    }
    func winCoins(coins: Int) {
        coinsInPurse += Bank.vendCoins(coins)
    }
    deinit {
        Bank.receiveCoins(coinsInPurse)
    }
}

var playerOne: Player? = Player(coins: 100)
println("A new player has joined the game with \(playerOne!.coinsInPurse) coins")
// 输出 "A new player has joined the game with 100  coins"
println("There are now \(Bank.coinsInBank) coins left   in the bank")


//自动引用计数的工作机制
//当你每次创建一个类的新的实例的时候，ARC 会分配一大块内存用来储存实例的信息。内存中会包含实例的类型信息，以及这个实例所有相关属性的值。此外，当实例不再被使用时，ARC 释放实例所占用的内存，并让释放的内存能挪作他用。这确保了不再被使用的实例，不会一直占用内存空间。
//无论你将实例赋值给属性，常量或者是变量，属性，常量或者变量，都会对此实例创建强引用。之所以称之为强引用，是因为它会将实例牢牢的保持住，只要强引用还在，实例是不允许被销毁的。
class Person {
    let name: String
    init(name: String) {
        self.name = name
        println("\(name) is being initialized");
    }
    deinit {
        println("\(name) is being deinitialized");
    }
}

var p1:Person?;
p1 = Person(name: "Michael");
var p2 = p1;
var p3 = p1;

class HTMLElement {
    
    let name: String
    let text: String?
    
    lazy var asHTML: () -> String = {
        if let text = self.text {
            //这个是一个必包的强引用
            return "<\(self.name)>\(text)</\(self.name)>"
        } else {
            return "<\(self.name) />"
        }
    }
    
    init(name: String, text: String? = nil) {
        self.name = name
        self.text = text
    }
    
    deinit {
        println("\(name) is being deinitialized")
    }
    
}

var paragraph: HTMLElement? = HTMLElement(name: "p", text: "hello, world")
println(paragraph!.asHTML());

//用类型检查操作符(is)来检查一个实例是否属于特定子类型。若实例属于那个子类型，类型检查操作符返回 true ，否则返回 false 。
class User{
    var name:String?;
    var age:Int?;
    
    init(name:String , age:Int){
        self.name = name;
        self.age = age;
    }
}

class Student{
    var basicUser:User;
    var type:String?;
    
    init(basicUser:User){
        self.basicUser = basicUser;
    }
}

class Teacher{
    var basicUser:User;
    var type:String?;
    
    init(basicUser:User){
        self.basicUser = basicUser;
    }
}

var stu = Student(basicUser: User(name: "Michael", age: 20));

var list = [Student(basicUser: User(name: "Michael", age: 20)),
Teacher(basicUser: User(name: "Michael", age: 20)),
Student(basicUser: User(name: "Michael", age: 20))];
for peo in list{
    if peo is User{
        println("This is basic User.");
    }else if peo is Student{
        println("This is Student.");
    }else if peo is Teacher{
        println("This is Teacher.");
    }
}

//某类型的一个常量或变量可能在幕后实际上属于一个子类。你可以相信，上面就是这种情况。你可以尝试向下转到它的子类型，用类型转换操作符(as)

//扩展
//声明一个扩展使用关键字extension
extension Double{
    var km:Double {
        return self * 1000.0;
    }
    var m:Double{
        return self;
    }
    var cm:Double{
        return self/100.0;
    }
}

var kmV:Double = 1.km;

//扩展可以向已有类型添加新的构造器。这可以让你扩展其它类型，将你自己的定制类型作为构造器参数，或者提供该类型的原始实现中没有包含的额外初始化选项。

extension Int {
    func showTimes(show: () -> ()) {
        for i in 0..<self {
            show();
        }
    }
}

4.showTimes({
    println("show");
});

extension Int {
    subscript(var index: Int) -> Int {
        var base = 1
        while index > 0 {
            base *= 10
            --index
        }
        return (self / base) % 10
    }
}

1232389_2323[4];