读Swift官方文档的收获(二)

<四>对象和类

1.使用class来声明一个类,有类似于java中类的定义和访问:
(1)使用点语法来访问实力的属性和方法,
(2)创建构造器使用的是init.
(3)在删除对象之前需要进行清理,使用deinit创建析构函数,
(4)子类的定义方法是在其类名的后面加上父类的名字,并用” : “隔开.
(5)子类如果想要重写父类的方法的话需要用override标记

    class NameShap : Name{         //继承于父类Name(例)
        var number : int = 0
        var name : string
        init(name :string) {
            self.name = name
        }
        override  func SimpleDescription ()->string {   //重写父类的方法(例)
        return "A shape with \(number) sides."
        }
    }
    创建实例: var nameShap = NameShap( )
    访问属性:nameShap.number = 8
    访问方法:var simpleDescription =  nameShap.SimpleDescription()

2.类中的方法和一般的函数有一个重要的区别,函数的参数只是在函数的内部使用,但是方法的参数名需要在调用的时候显示说明,默认情况下,方法的参数名和它在方法内部的名字一样.
3.处理变量的可选值时,可以在操作（比如方法、属性和子脚本）之前加?。如果?之前的值是nil,?后面的东西都会被忽略，并且整个表达式返回nil。否则，?之后的东西都会被运行。
let optionalSquare: Square? = Square(sideLength: 2.5, name: “optional square”)

<五>枚举和结构体

1.枚举的创建依然使用enum, 而且枚举可以同其他所有的命名类型一样可以包含方法.

    enum Rank: Int { 
        case Ace = 1 
        case Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten 
        case Jack, Queen, King 
        func simpleDescription() -> String { 
            switch self { 
            case .Ace: 
                return "ace" 
            case .Jack: 
                return "jack" 
            case .Queen: 
                return "queen" 
            case .King: 
                return "king" 
            default: 
                return String(self.toRaw()) 
            } 
        } 
    } 
    let ace = Rank.Ace 
    let aceRawValue = ace.toRaw() 

2.结构体.使用struct来创建,结构体和类有很多相同的地方，比如方法和构造器。它们结构体之间最大的一个区别就是 结构体是传值，类是传引用, 而且结构体不能被继承。

struct Point {    //结构体
    var x = 0.0
    var y = 0.0
}
struct Size {
    var width = 0.0
    var height = 0.0
}
struct MyRect {
var origin = Point()  //  存储属性
var size = Size()
var center:Point{     //  计算属性
    get{
        let centerX = origin.x + size.width / 2
        let centerY = origin.y + size.height / 2
        return Point(x : centerX, y : centerY)
    }
    set(newCenter){
        origin.x = newCenter.x - size.width / 2
        origin.y = newCenter.y - size.height / 2
    }
}
init(origin:Point, size:Size){ //  计算属性
    self.origin = origin
    self.size = size
    }
}   
    var myFrame = MyRect(origin: Point(x: 0.0, y: 0.0), size: Size(width: 100, height:100))
    myFrame.center

<六>接口和扩展

1.使用protocol来声明一个接口(ios中叫做协议)

    protocol ExampleProtocol { 
        var simpleDescription: String { get } 
        mutating func adjust() 
    } 

类、枚举和结构体都可以实现接口。

    //类签订协议如果该类还继承父类则可以写为  : 父类名 , 协议名
    class SimpleClass: ExampleProtocol { 
        var simpleDescription: String = "A very simple class." 
        var anotherProperty: Int = 69105 
        func adjust() { 
            simpleDescription += "  Now 100% adjusted." 
        } 
    } 
    var a = SimpleClass() 
    a.adjust() 
    let aDescription = a.simpleDescription 
     //结构体 
    struct SimpleStructure: ExampleProtocol { 
        var simpleDescription: String = "A simple structure" 
        mutating func adjust() { 
            simpleDescription += " (adjusted)" 
        } 
    } 
    var b = SimpleStructure() 
    b.adjust() 
    let bDescription = b.simpleDescription 

声明SimpleStructure时候使用mutating关键字用来标记一个会修改结构 体的方法。SimpleClass的声明不需要标记任何方法因为类中的方法经常会修改类。
2.扩展 :使用extension来为现有的类型添加功能,可以使用扩展来给任意类型添加协议,甚至是从外部库或者框架中导入的类型.

    extension Int: ExampleProtocol { 
        var simpleDescription: String { 
        return "The number \(self)" 
        } 
        mutating func adjust() { 
            self += 42 
        } 
    } 
     print(7.simpleDescription)

<七>泛型

表示木有看的很明白,泛型到底怎么用,贴上了文档的翻译.
在尖括号里写一个名字来创建一个泛型函数或者类型。
func repeatItem<Item>(item: Item, numberOfTimes: Int) -> [Item] {
var result = [Item]()
for _ in 0..<numberOfTimes {
    result.append(item)
}
return result
}
repeatItem("knock", numberOfTimes:4)

你可以创建泛型函数和方法,还可以创建类,枚举,结构体

// Reimplement the Swift standard library's optional type
enum OptionalValue<Wrapped> {
case None
case Some(Wrapped)
}
var possibleInteger: OptionalValue<Int> = .None
possibleInteger = .Some(100)

在类型名后面使用where来指定一个需求列表——例如，要限定实现一个协议的类型，需要限定两个类型要相同，或者限定一个类必须有一个特定的父类。

func anyCommonElements <T: SequenceType, U: SequenceType where T.Generator.Element: Equatable, T.Generator.Element == U.Generator.Element> (lhs: T, _ rhs: U) -> Bool {
for lhsItem in lhs {
    for rhsItem in rhs {
        if lhsItem == rhsItem {
            return true
        }
     }
  }
return false
}
anyCommonElements([1, 2, 3], [3])

简单起见，你可以忽略where，只在冒号后面写接口或者类名。和是等价的。