Swift教程_零基础学习Swift完整实例（三）_swift基础（对象和类、枚举和结构、协议和扩展、泛型）

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() -&gt; 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() -&gt;  double {  

        return sidelength * sidelength  

    override func simpledescription() -&gt; 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.在&lt;&gt;里写一个名字来创建一个泛型方法或者类型。 也可以创建泛型类、枚举和结构体。

func repeat&lt;t&gt;(item: t, times: int) -&gt; [t] {  

    var result = [t]()  

    for i in 0..&lt;times {  

        result.append(item)  

    return result  

repeat("knock", 4)//["knock", "knock", "knock", "knock"]  

2.在类型名后面使用<code>where</code>来指定一个需求列表，例如要限定实现一个协议的类型，需要限定两个类型要相同，或者限定一个类必须有一个特定的父类。简单起见，可以忽略<code>where</code>，只在冒号后面写接口或者类名。<code>&lt;t: equatable&gt;</code>和<code>&lt;t where t: equatable&gt;</code>是等价的。

func anycommonelements &lt;t, u where t: sequencetype, u: sequencetype, t.generator.element: equatable, t.generator.element == u.generator.element&gt; (lhs: t, rhs: u) -&gt; 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 &lt;t, u, r where t: sequencetype, u: sequencetype, t.generator.element: equatable, t.generator.element == u.generator.element, r == t.generator.element&gt; (lhs: t, rhs: u) -&gt; [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