swift学习-类型转换，嵌套类-2016/1/1

昨天买的车票挺晚的，又恰逢火车站在整修。排了半天队没打到出租车，只有走回家了。到家的时候12点多，索性把昨天的东西合到今天一起发了。
今天是1月1号，新的一年了。虽然并没有什么特别的（前面已解释过）。
下午看了一会书，晚上少看了一会，看到190页了，明天加油，争取到200页。
笔记如下：
1 类型转换
类中转换在swift中通过is和as操作符实现。

class MediaItem {
    var name: String

    init(name: String) {
        self.name = name
    }
}

class Movie: MediaItem {
    var director: String

    init(name: String, director: String) {
        self.director = director
        super.init(name: name)
    }
}

class Song: MediaItem {
    var artist: String

    init(name: String, artist: String) {
        self.artist = artist
        super.init(name: name)
    }
}

let library = [
    Movie(name: "abc", director: "def"),
    Song(name: "abcd", artist: "xxxx")
] //推测类型为MediaItem

var movies = 0
var songs = 0

for item in library {
    if item is Movie {
        movies++
    }    

    if item is Song {
        songs++
    }
}

print(movies)
print(songs)

for item in library {
    if let movie = item as? Movie {
        print("move: '\(movie.name), dir. \(movie.director)")
    } else if let song = item as? Song {
        print("song: \(song.name)， by \(song.artist)")
    }
}

2 AnyObject和Any类型。
AnyObject是一个协议，Any是零个协议。AnyObject用于任何类实例，而Any用于任何变量。
AnyObject只能用于类，不能用于结构。而Any则任意。

var things = [Any]()

things.append(0)
things.append(1)
things.append("abc")
things.append(2.3)
things.append({(myStr: String) -> String in return "\(myStr) hello"})

for thing in things {
    switch thing {
    case 0 as Int:
        print("0")
    case let i as Int:
        print("Int \(i)")
    case let str as String:
        print("string \(str)")
    case let fun as String -> String:
        print("fun " + fun("sigh"))
    default:
        print("other thing")
    }
}

3 可以在枚举中，类和结构体中定义支持嵌套的类型。

struct BlackjackCard {
    enum Suit: Character { //原始值为Character
        case Spades = "?", Hearts = "?", Diamonds = "?", Clubs = "?"
    }

    enum Rank: Int {
        case Two = 2, Three, Four
        case Jack, Queen        

        struct Values {
            let first: Int
            let second: Int?
        }        

        var values: Values {
            switch self {
            case .Jack:
                return Values(first: 1, second: 12)
            case .Queen:
                return Values(first: 10, second: nil)
            default:
                return Values(first: self.rawValue, second: nil)
            }
        }
    }

    let rank: Rank
    let suit: Suit
  
    var description: String {
        var output = "suit is \(suit.rawValue)"
        
        output += " value is \(rank.values.first)"     

        if let second = rank.values.second {
            output += " or \(second)"
        }        

        return output
    }
}

var blackjackCard = BlackjackCard(rank: .Two, suit: .Spades)

print(blackjackCard.description)

4 扩展，扩展就是像一个已有类，结构体或者枚举类型添加新功能。这包括在没有权限获取原始源代码的情况下扩展类型的能力。
swift中的扩展可以：
添加计算性属性和计算静态属性
定义实例方法和类型方法
提供新的构造器
定义下标
定义和使用新的嵌套类型
使已有的类型符合某个协议

extension Double {
    var km: Double {
        return self * 1000.0
    }   

    var cm: Double {
        return self / 100
    }
}

let oneKm = 1.0.km

扩展可以添加新的计算属性，但是不可以添加存储属性，也不可以向已有属性添加属性观察器。

swift的扩展感觉还是有点意思。这里面可以玩出许多有趣的东西，写代码，需要很多的想象力的。
加油。