swift2.0 学习笔记Seventeen

import UIKit

//结构体和枚举是值类型

//值类型被赋予给一个变量、常量或者被传递给一个函数的时候,其值会被拷贝。

struct BlackjackCard {

    //嵌套定义枚举型suit

    enum Suit:
String {//定义了原始值

        case Spades =
"红桃", Hearts =
"黑桃", Diamonds =
"方片" ,Clubs =
"梅花"

    }

    //嵌套定义枚举Rank

     enum Rank:
Int{

        case Two = 2,Three,Four,Five,Six,Seven,Eight,Nine,Ten

        case J,Q,K,A

        struct Values {

            let first :
Int,second :Int?

        }

        var values:Values{

            

            switch
self{

            case .A:

                return
Values(first: 1, second: 11)

            case .J, .Q, .K:

                return
Values(first: 10, second:
nil)

            default:

                return
Values(first: self.rawValue, second:
nil)

            }

        }

    }

    

    

    //BlackjackCard 的属性和方法

    let rank :Rank,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

    }

    

}

class ViewController: UIViewController {

    

    override
func viewDidLoad() {

        super.viewDidLoad()

        //嵌套类型

       
//枚举类型常被用于实现特定类或结构体的功能。也能购在有多种变量类型的环境中，方便地定义通用类或结构体来使用。为了实现这种功能，swift允许你定义嵌套类型，可以在枚举类型、类、和结构体中定义支持嵌套的类型

       let theAceOfSpades =
BlackjackCard(rank: .A, suit: .Hearts)

        print("theAofHearts:\(theAceOfSpades.description)")

        //theAofHearts:suit is
黑桃value is 1or 11

        let theAceOfSpades2 =
BlackjackCard(rank: .Four, suit: .Hearts)

        print("theAofHearts:\(theAceOfSpades2.description)")

        //theAofHearts:suit is
黑桃value is 4

       
//尽管Rank和Suit嵌套在BlackjackCard中，但仍可被引用，所以在初始化实例时能够通过枚举类型中的成员名称单独引用。

        

       
//在外部对嵌套类型的引用，以被嵌套类型的名字为前缀，加上所要引用的属性名

        let heartsSymbol =
BlackjackCard.Suit.Hearts.rawValue

        print("\(heartsSymbol)")//黑桃

        

        //扩展（Extensions）

       
//扩展就是向一个已有的类、结构体、枚举类型或协议类型添加新功能。

        //与oc不同的是，swift的扩展没有名字

       
//swift中的扩展可以：添加计算型属性和计算型静态属性、定义实例方法和类型方法、提供新的构造器、定义下标、定义和使用新的嵌套类型、使一个已有类型符合某个协议

       
//扩展可以对一个类型添加新的功能，但是不能重写已有的功能

        

       
//扩展可以向已有类型添加计算型实例属性和计算型属性。

        let oneInch = 25.4.mm

        print("One inch is
\(oneInch) meters")//One inch is 0.0254 meters

        let threeFeet = 3.ft

        print("Three feet is
\(threeFeet) meters")//Three feet is 0.914634146341463 meters

        let aMarathon = 42.km + 195.m

        print("A marathon is
\(aMarathon) meters long")

        //A marathon is 42195.0 meters long

        

       
//扩展能向类中添加新的便利构造器，但是它们不能向类中添加新的指定构造器或析构器。指定构造器和析构器必须总是由原始的类实现来提供

       
//因为结构体Rect提供了其所有属性的默认值，所以它可以自动接受一个默认构造器和一个逐一成员构造器。

        let defaultRect =
Rect()

        let otherRect =
Rect(origin: Point(x: 2.0, y: 2.0), size:
Size(width: 5.0, height: 5.0))

        let centerRect =
Rect(center: Point(x: 4.0, y: 4.0), size:
Size(width: 3.0, height: 3.0))

        

       
//扩展可以向已有类型添加新的实例方法和类型方法。

        4.repetitions { () -> ()
in

            print("hello!")

        }//尾随闭包

//        hello!

//        hello!

//        hello!

//        hello!

       

       
//通过扩展添加的实例方法也可以修改该实例本身。结构体和枚举类型中修改self或其属性的方法必须将该实例方法标注为mutaing。

        var someInt = 3

        someInt.square()

        print("\(someInt)");//9

        

        

       
//扩展可以向一个已有类型添加新下标。

        print(12345[0])//5

        print(12345[1])//4

        

        

       
//扩展可以向已有的类、结构体和枚举添加新的嵌套类型

        printIntKinds([3,-4,0,5,-6])

        //+ － 0 +
－

    }

}

func printIntKinds(numbers:[Int]){

    for number
in numbers{

        switch number.kind{//已知number.kind是Int.Kind型，所以使用.Negative代替Int.kind.Negative

        case .Negative:

            print("－")

        case .Zero:

            print("0")

        case .Positive:

            print("+")

        }

    }

}

extension Int{

    enum Kind{//添加了新的嵌套枚举

        case Negative,Zero,Positive

    }

    var kind:Kind{

        switch
self{

        case 0:

        return .Zero

        case
let x where x>0:

        return .Positive

        default:

        return .Negative

        }

    }

}

extension Int{

    subscript(var digitIndex:Int)->Int{

        var decimalBase=1

        while digitIndex > 0{

            decimalBase *= 10

            --digitIndex

        }

        return (self / decimalBase) % 10

    }

}

extension
Int{//结构体和枚举类型中修改self或其属性的方法必须将该实例方法标注为mutaing。

    mutating
func square(){

        self =
self * self

    }

}

extension Int{

    func repetitions(task:()->()){//()->()表明函数没有参数而且没有返回值。

        for i
in 0..<self{

            task()

        }

    }

}

extension Rect{

    init(center:Point,size:Size){

        let originX = center.x - (size.width/2)

        let originY = center.y - (size.height/2)

        self.init(origin:Point(x: originX, y: originY),size:size)//自带的逐一成员构造器

        

    }

}

struct Size {

    var width = 0.0, height = 0.0

}

struct Point {

    var x = 0.0, y = 0.0

}

struct Rect {

    var origin =
Point()

    var size =
Size()

}

extension Double{

    var km :Double{return
self * 1_000.0}

    var m :Double{return
self}

    var cm:
Double{return
self / 100.0}

    var mm :Double {return
self / 1_000.0}

    var ft :
Double{return
self / 3.28}

}