2.使用<code>init</code>建立一個構造方法，使用<code>deinit</code>建立一個析構方法，通過構造方法來初始化類執行個體。建立類執行個體同java一緻，在類名後面加上()(實際是調用無參數的構造方法init()，構造方法也可以帶參數)。使用.來通路執行個體的屬性和方法。
class namedshape {
var numberofsides: int = 0//每個屬性都需要初始化一個值——無論是通過聲明（就像numberofsides）還是通過構造器（就像name）。
var name: string
init(name: string) {
self.name = name//self同java中的self，隐示參數，表示類執行個體
}
func simpledescription() -> string {
return "a shape with \(numberofsides) \(name) sides."
}
var namedshape = namedshape(name: "popkidorc")
namedshape.simpledescription()//a shape with 0 popkidorc sides.
3.子類的定義方法是在它們的類名後面加上父類的名字，用:分割。建立類的時候可以忽略父類。子類如果要重寫父類的方法的話，需要用<code>override</code>标記（與java不同，若沒有添加<code>override</code>就重寫父類方法的話編譯器會報錯，編譯器同樣會檢測<code>override</code>标記的方法是否确實在父類中）。
class square: namedshape {
var sidelength: double
init(sidelength: double, name: string) {
self.sidelength = sidelength
super.init(name: name)
numberofsides = 4
func area() -> double {
return sidelength * sidelength
override func simpledescription() -> string {
return "a square with sides of length \(sidelength)."
let test = square(sidelength: 5.2, name: "my test square")
test.area()//27.04
test.simpledescription()//a square with sides of length 5.2.
4.類的屬性可以有getter和setter，如果不需要計算屬性，但要在設定一個新值之前或之後運作一些代碼，使用<code>willset</code>和<code>didset</code>。
class equilateraltriangle: namedshape {
var sidelength: double = 0.0
self.sidelength = sidelength//設定子類聲明的屬性值
self.area = sidelength*1.732/2
super.init(name: name)//調用父類的構造器
numberofsides = 3//改變父類定義的屬性值。
//其他的工作比如調用方法、getters和setters也可以在這裡執行。
var perimeter: double {
get {
return 3.0 * sidelength
}
set {
sidelength = newvalue / 3.0//新值的名字是newvalue
var area: double {
willset{
println("an new value \(newvalue)")
return "an equilateral triagle with sides of length \(sidelength)."
var triangle = equilateraltriangle(sidelength: 3.1, name: "a triangle")
triangle.perimeter//9.3
triangle.perimeter = 9.9
triangle.sidelength//3.3
triangle.perimeter//9.9
triangle.area//2.6846
5.方法的參數名除了第一個外，都需要在調用的時候顯式說明。方法的參數名預設和它在方法内部的名字一樣，也可以定義另一個名字，在方法内部使用。
class counter {
var count: int = 0
func incrementby(amount: int, numberoftimes times: int) {
count += amount * times
var counter = counter()
counter.incrementby(2, numberoftimes: 7)//14
6.操作可選值變量時，可以再在操作（比如方法、屬性和子腳本）之前加<code>?。</code>如果<code>?</code>之前的值是<code>nil，</code><code>?</code>後面的東西都會被忽略，并且整個表達式傳回<code>nil</code>。否則，<code>?</code>之後的東西都會被運作。在這兩種情況下，整個表達式的值也是一個可選值。
let optionalsquare: square? = square(sidelength: 2.5, name: "optional square")
let sidelength = optionalsquare?.sidelength//操作前加?
1.使用<code>enum</code>來建立一個枚舉。和類一樣，枚舉可以包含方法。使用case聲明枚舉成員。
2.枚舉的成員還可以設定預設值（當然可以不用設定，預設從0開始的整數，0、1、2），我們叫原始值，這些值的類型是相同的，并且設定了為第一個成員的原始值後，剩下成員的原始值會按照順序指派。通過<code>toraw</code>方法擷取成員的原始值，<code>fromraw</code>方法嘗試通過原始找到枚舉成員（若找不到則為nil）。
enum rank: int {
case ace = 1
case two, three, four, five, six, seven, eight, nine, ten
case jack, queen, king
switch self {
case .ace://枚舉成員使用縮寫.ace來引用，因為已經知道self的值是一個rank。已知變量類型的情況下可以使用縮寫。
return "ace"
case .jack:
return "jack"
case .queen:
return "queen"
case .king:
return "king"
default:
return string(self.toraw())
let ace = rank.ace//枚舉成員rank.ace需要用全名來引用，因為常量ace沒有顯式指定類型。
let acerawvalue = ace.toraw()//1
if let convertedrank = rank.fromraw(1) {
let threedescription = convertedrank.simpledescription()//ace
3.使用<code>struct</code>來建立一個結構。結構和類有很多相同的地方，比如方法和構造器。它們之間最大的差別就是結構是傳值，類是傳引用。
struct card {
var rank: rank
return "the \(rank.simpledescription())"
let threeofspades = card(rank: .three)
let threeofspadesdescription = threeofspades.simpledescription()//the 3
4.一個枚舉的成員可以有執行個體值（也可以叫關聯值）。相同枚舉成員的執行個體值可能不同，建立枚舉執行個體的時候傳入。而在定義枚舉時候設定的原始值對于所有執行個體都是相同的。
enum serverresponse {
case result(string, string)
case error(string)
let success = serverresponse.result("6:00 am", "8:09 pm")//執行個體值
let failure = serverresponse.error("out of cheese.")
switch success {
case let .result(sunrise, sunset):
let serverresponse = "sunrise is at \(sunrise) and sunset is at \(sunset)."//sunrise is at 6:00 am and sunset is at 8:09 pm.
case let .error(error):
let serverresponse = "failure... \(error)"
1.使用<code>protocol</code>來聲明一個協定，類似于java中的接口，為了和interface做為差別我們叫做協定。類、枚舉和結構都可以實作協定(發現枚舉實作協定協定中好像不能帶有屬性，希望大神指教)。
protocol exampleprotocol {
var simpledescription: string { get }//在屬性聲明後寫上{ get set }表示屬性為可讀寫的。{ get }表示屬性為可讀的。即使為可讀的屬性實作了setter方法，它也不會出錯。
mutating func adjust()//mutating關鍵字用來标記一個會修改結構體的方法
class simpleclass: exampleprotocol {
var simpledescription: string = "a very simple class."
var anotherproperty: int = 69105
func adjust() {//不用mutating标記，因為class中的方法經常會修改類
simpledescription += " now 100% adjusted."
var a = simpleclass()
a.adjust()
let adescription = a.simpledescription//a very simple class. now 100% adjusted.
struct simplestructure: exampleprotocol {
var simpledescription: string = "a simple structure"
mutating func adjust() {
simpledescription += " (adjusted)"
var b = simplestructure()
b.adjust()
let bdescription = b.simpledescription//a simple structure (adjusted)
2.使用<code>extension</code>來為現有的類型添加功能（稱作擴充），比如添加一個計算屬性的方法。可以使用擴充來給任意類型添加協定，甚至是你從外部庫或者架構中導入的類型。
extension int: exampleprotocol {
var simpledescription: string {
return "the number \(self)"
self += 42
var i = 7;
i.adjust()//直接寫7.adjust()會有異常，這是因為7是常量，而adjust是mutating改變類方法
i.simpledescription//the number 49
i//49
3.可以像使用其他命名類型一樣使用協定名，可以建立一個有不同類型，但是都實作一個協定的對象集合。當處理類型是協定的值時，協定外定義的方法不可用。
let protocolvalue: exampleprotocol = a
protocolvalue.simpledescription
// protocolvalue.anotherproperty // uncomment to see the error
1.在<>裡寫一個名字來建立一個泛型方法或者類型。 也可以建立泛型類、枚舉和結構體。
func repeat<t>(item: t, times: int) -> [t] {
var result = [t]()
for i in 0..<times {
result.append(item)
return result
repeat("knock", 4)//["knock", "knock", "knock", "knock"]
2.在類型名後面使用<code>where</code>來指定一個需求清單，例如要限定實作一個協定的類型，需要限定兩個類型要相同，或者限定一個類必須有一個特定的父類。簡單起見，可以忽略<code>where</code>，隻在冒号後面寫接口或者類名。<code><t: equatable></code>和<code><t where t: equatable></code>是等價的。
func anycommonelements <t, u where t: sequencetype, u: sequencetype, t.generator.element: equatable, t.generator.element == u.generator.element> (lhs: t, rhs: u) -> bool {//限定sequencetype類型，并且element實作equatable協定，該協定要求任何遵循的類型實作等式符（==）和不等符（!=）對任何兩個該類型進行比較。
for lhsitem in lhs {
for rhsitem in rhs {
if lhsitem == rhsitem {
return true
}
return false
anycommonelements([1, 2, 3], [3,4])//true
func anycommonelementsnew <t, u, r where t: sequencetype, u: sequencetype, t.generator.element: equatable, t.generator.element == u.generator.element, r == t.generator.element> (lhs: t, rhs: u) -> [r] {//限定序列sequencetype類型，并且element實作equatable協定，該協定要求任何遵循的類型實作等式符（==）和不等符（!=）對任何兩個該類型進行比較。
var results = [r]()
results.append(lhsitem)
return results
anycommonelementsnew(["1", "2", "3", "4"], ["3","4","6"])//["3", "4"]
原文位址：http://blog.csdn.net/ooppookid/article/details/40345557
![Java小案例——随機數猜測随機數猜測[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)