初探Swift,Swift类,Swift类的实例化,Swift类的操作等是本文的内容。这是一门强类型、完全面相对象的语言。类可以更好的封装、抽象、复用模块和代码,使得代码更加的优雅简洁。

/**

 * 类

 */

//定义一个类

class TV{

    //定义属性

    var price = 1999

    var name = "乐TV"

    //定义方法

    func open()->String{

        return "Success"

    }

    func close()->Bool{

        return true

    }

}

//创建对象,不需要new这个关键字的

var myTV = TV()

//调用类的属性

println(myTV.name)

//调用类的方法

myTV.open()

myTV.close()

//类的对象是值调用还是引用调用。

var myTV2 = myTV

//改变myTV2的价格

myTV2.price = 2000

//打印myTV2的价格,是2000,修改成功

myTV2.price

//打印myTV1的价格,是2000,说明是引用传递的

myTV.price


//可以用“===”来判断使用来自同一个类

myTV === myTV2


//swift是没有指针概念的:因为虽然引用传递用的还是指针,但是swift并没有给我们指针的语法


/**

 * 类的构造函数、析构函数

 */

class People{

    var name:String = "小明"

}

var peopleObj = People()

//结果是小明

peopleObj.name

//增加析构函数后

class People2{

    var name:String = "小明"

    //析构函数,系统特殊函数,不需要加func

    init(name:String){

        self.name = name

    }

    //析构函数,系统特殊函数,不需要加func和()

    deinit {

        name = ""

    }

}

var peopleObj2 = People2(name: "小红")

peopleObj2.name



/**

 * 类的继承

 */

//学生类继承人类类

class Student : People{}

var studentObj = Student()

studentObj.name


class Student2 : People2{

    override init(name:String){

        //父类的构造函数需要手动调用,不会自动执行

        super.init(name: "小红")

        super.name = "hello: \(super.name)"

        self.name = name

    }

    //重写父类的函数需要加关键词override

    

    //重写属性

    override var name:String{

        get{

            return super.name

        }

        set{

            super.name = "hi \(name)"

        }

    }

    

    //不希望被重写,再父类的方法前面加@final。可以加在方法、属性、设置类前面

}

var studentObj2 = Student2(name: "小白")

println(studentObj2.name)

studentObj2.name = "lane"

println(studentObj2.name)

    初探Swift,Swift枚举。Swift枚举不同于C语言的枚举,C的枚举只能关联一个整形,而Swift枚举不但可以关联一个整形,更可以关联任意的数据类型。

    声明用enum开头,case 后面跟一个元素。可以不像C语言那样和整数关联。如下,ExamScore不是一个变量,而是一个数据类型,这个数据类型叫做ExamScore,同Int,String一样。

import UIKit

/**

 * 枚举(Enumerations)

 */

//声明用enum开头,case 后面跟一个元素。可以不像C语言那样和整数关联。如下,ExamScore不是一个变量,而是一个数据类型,这个数据类型叫做ExamScore,同Int,String一样。

enum ExamScore{

    case score_a

    case score_b

    case score_c

}

var myScore:Int = 40

//声明一个变量是刚才声明的ExamScore类型

var rank:ExamScore

if myScore >= 90 {

    //使用枚举:“枚举变量.枚举元素”

    rank = ExamScore.score_a

}else if myScore >= 60 {

    //使用枚举:枚举变量可以省略,只要“.枚举元素”

    rank = .score_b

}else{

    rank = .score_c

}

rank

switch rank{

    case .score_a:

        println("A等成绩")

    case .score_b:

        println("B等成绩")

    case .score_c:

        println("C等成绩")

}


/**

 * 枚举 - 关联一个值

 */

enum Month:Int{

    case Jan=1, Feb, Mar

}

//声明了Jan=1,Feb和Mar系统会自动赋值为2和3

//使用

//此时值为1

Month.Jan.rawValue

//另一种好似用方式

var myMonth:Month

myMonth = .Jan

myMonth.rawValue

//寻找关联值为2的那个枚举元素,返回一个可选型,因为如果寻找1000的那个元素,是找不到。

var nextMonth = Month(rawValue: 2)

nextMonth!.rawValue

//不仅仅,还可以关联字符串

enum MonthString:String{

    case Jan="一月"

    case Feb="二月"

    case Mar="三月"

}

//一月

MonthString.Jan.rawValue



/**

 * 复杂的枚举

 */

enum UserInfo{

    case birthday(Int, Int, Int)

    case name(String)

}

let xiaomingBirthday = UserInfo.birthday(1990, 1, 10)

let xiaomingName:UserInfo = .name("小明")


switch xiaomingBirthday{

    case .birthday(let year, let month, let day):

        println("\(year)年\(month)月\(day)")

    case .name(let name):

        println("大家号,我叫\(name)")

}


    初探Swift,本文关于Swift闭包、Swift闭包特性(比如结尾闭包和捕获参数)、Swift闭包引用类型的相关介绍与实践。swift闭包一个很重要的特性,可以简化代码,优化流程。使代码更加简洁。

    一、闭包(Closure),将函数的声明和逻辑代码都放在参数的位置,闭包的本质还是函数。

import UIKit

/**

 *闭包(Closure),将函数的声明和逻辑代码都放在参数的位置,闭包的本质还是函数。

 */

var arr = [2, 1, 5, 3, 9, 0, 4]

//使用闭包将数组从大到小排列,sorted不穿第二个参数时默认为从下到大,闭包放在{}中,用()来声明2个变量,->来声明返回值,后面跟一个in,逻辑代码放在in后面。

var result = sorted(arr, {(a:Int, b:Int)->Bool in

    return a > b

})

result

//闭包的简化操作,闭包中2个参数的类型可以省略,返回值声明可以省略

result = sorted(arr, {a, b in return a > b})

result

//闭包进一步简化,省略return

result = sorted(arr, {a, b in a>b})

result

//闭包再进一步优化,省略a,b两个参数声明,用$0, $1来代替,省略in关键字

result = sorted(arr, {$0 > $1})

//再省,因为“>”就是函数,是运算符函数

result = sorted(arr, >)

//注:必须是单行的才可以省略return, in已经ab的声明

result

    二、结尾闭包,闭包的参数里面{},看起来别扭,而且开发时可能会出现括号的对应问题。当传入闭包是最后一个参数的时候,可以使用如下的方式。仅仅是最后一个的时候可以!

/**

 *结尾闭包,闭包的参数里面{},看起来别扭,而且开发时可能会出现括号的对应问题。当传入闭包是最后一个参数的时候,可以使用如下的方式。仅仅是最后一个的时候可以!

 */

result = sorted(arr){a, b in

    return a > b

}

result

    三、捕获参数(capturing values)我们可以在闭包中使用闭包外的变量

/**

 *捕获参数(capturing values)我们可以在闭包中使用闭包外的变量

 */

var num = 3

result = sorted(arr){

    return fabs(Float($0-num)) < fabs(Float($1-num))

}

result

    四、引用类型:将函数(闭包)赋值给函数类型的变量A,函数类型的变量A再赋值给函数类型的变量B,那么,A和B是指向同一块地址的,调用A引起的变化再变量B中将会体现

/**

 *引用类型

 */

func calcTotalMiles(todayMiles:Int)->()->Int{

    var totalMiles = 0

    return {totalMiles += todayMiles; return totalMiles;}

}

var dailyTwoMiles = calcTotalMiles(2)

//结果:2

dailyTwoMiles()

//结果:4

dailyTwoMiles()

//把函数复制给另一个变量

varmyPlan =dailyTwoMiles

//调用这个变量

//结果:6

myPlan()

//结果:8

myPlan()

//回过头来调用之前被赋值的变量(函数类型的变量),看值是否改变

//结果:10

dailyTwoMiles()

//说明这个是引用传递的,函数类型的变量myPlan和函数类型的变量dailyTwoMiles是指向同一个地址的。


/**

 *创建函数

 * 参数是String,返回值是String。其中参数和返回值都是可选的,但是如果有参数,或者有return,则是必须的

 */

func sayHello(name:String)->String{

    return "Hello "+name+"."

}

println(sayHello("lane"))


func sayHelloOptional(name:String?)->String{

    var result = "Hello," + (name ?? "Guest")

    return result

}

var name:String?

println(sayHelloOptional(name))


/**

 *函数和元组

 * 参数是String,返回值是String。其中参数和返回值都是可选的

 */

func maxMinScores( scores:[Int] )->( maxScore:Int, minScore:Int)?{

    if scores.isEmpty{

        return nil

    }

    var curmax = scores[0]

    var curmin = scores[0]

    for score in scores[1..<scores.count]{

        curmax = max(curmax, score)

        curmin = min(curmin, score)

    }

   //两种返回方式

    return (maxScore:curmax, minScore:curmin)

   //两种返回方式

   //return (curmax, curmin)

}


var userScores:[Int]? = [12, 990, 572, 3258, 9999, 1204]

userScores=userScores?? []

if let maxMin = maxMinScores(userScores!){

    maxMin.maxScore

    maxMin.minScore

}


/**

 *值传递、引用、默认情况

 */

//默认下不能对参数修改,只能读取。此时参数被称为常数参数

func paramTest(varName:Int)->Int{

    var sum = varName*2;

   //报错,不能对参数修改,只能读

   //varName--;

    return sum

}

//值传递,可读可写,变量前面加一个var

func paramTest1(var varName:Int)->Int{

    var sum = varName*2;

   //这个时候下句不报错了。

    varName--;

    return sum

}

//引用,可读可写,变量前面加一个inout,使用时加&

func paramTest2(inout varName:Int)->Int{

    var sum = varName*2;

   //这个时候下句不报错了。

    varName--;

    return sum

}

var param = 10;

paramTest(param)

//param = 10

paramTest1(param)

//param = 10

paramTest2(&param)

//param = 9



/**

 *函数类型

 */

func add(a:Int, b:Int)->Int{

    return a+b

}

//隐式声明一个函数类型

let funcVar = add

add(3, 4)

//显式声明一个函数类型

let funcVar2:(Int, Int)->Int = add

//显式声明一个不需要参数和返回值的函数类型

func voidFunc(){

   println("hello world")

}

//let funcVar3:()->() = voidFunc

let funcVar4:()->Void = voidFunc


/**

 *函数嵌套

 */

func sum(a:Int, b:Int)->Int{

    func num(c:Int)->Int{

        return c*c

    }

    return num(a) + num(b)

}

sum(10, 20)


/**

 *返回函数类型的函数

 */

func func1(a:Int)->String{

    return "结果是"+String(a * a)

}

func func2(a:Int)->String{

    return "结果是"+String(a + a)

}

func choseFunc(a:Int)->(Int)->String{

    var result:(Int)->String

    if a%2==0 {

        result = func1

    }else{

        result = func2

    }

    return result

}

var funcName = choseFunc(10)

funcName(10)

funcName=choseFunc(5)

funcName(5)




    Swift条件控制,有for,for...in...,switch,if...else,while等,而跳出条件控制有break,continue,fallthrough。本篇文章变分析这几个控制的特性。

    for in相关的如下:

/**

* for - in 循环

*/

//for循环 >=-10 <=10

for i in -10...10{

    i*i

}

//遍历一个数组

var arr = ["a", "b", "c"]

for a in arr{

    println(a)

}

for (key, value) in enumerate(arr){

    println("\(key):\(value)")

}

//遍历一个字典

vardict = ["a":"A","b":"B","c":"C"]

for (key, value) in dict{

    println("\(key):\(value)")

}

    for相关的如下:

/**

* for 循环

*/

//等同for var i = -100; i<=100; i++

var i = -10

for ; i<=10; i++

{

    i*i

}

    if相关的如下:

//if else

iftrue{

    

}else{

    

}

    switch相关的如下:

/**

 *switch,可以对IntStringBoolFloatDouble进行判断

 *

 *不需要显式写break;

 */

var switchValue = "a"

switchswitchValue{

    case "a":

        println("a")

    case "b":

        println("b")

   default:

        println("d")

}

//判断多个值不能写:

//case "a":

//case "A":

//  println("ok");

//而是应该写:

//case "a", "A":

    switch高级特性相关的如下:

/**

 * switch高级特性

 */

//元组在switch

//如果想执行第一个case后还想执行第二个case,则添加fallthrough,此时直接进入下面的语句,不进行case判断

var request = (true, "success")

switchrequest{

   //这个是正确的

    case (true, "success"):

       println("true, success")

       fallthrough

   //这个也是正确的,可以忽略元组的第一个元素,将剩下的元素判断

    case (true, _):

       println("true, success")

   //这个也是正确的

    case (true, let requestStatus):

        println("当前登陆状态为:\(requestStatus)");

   default:

       println("not found!")

}

//switch可以比较范围

var request2 = (5, 12);

switchrequest2{

    case (1...8, 10...20):

        println("ok")

   default:

       println("not found!")

}

//switchcase中可以增加逻辑判断

var request3 = (3, 3)

switchrequest3{

    case let(x, y) where x==y:

        println("\(x)->\(y)")

   default:

       println("not found!")

}

    控制转移相关的如下,break只能跳出一层循环,如果要跳出多层,可以看下面的例子。另外break只能跳出循环,而不是花括号得代码块,比如if:

/**

 *控制转移

 * fallthroughbreakcontinue

 */

import UIKit

var board = Array<Array<Int>>()

for i in 0...10{

    board.append(Array(count:10, repeatedValue:0))

}

let x = Int(arc4random()%10)

let y = Int(arc4random()%10)

board[x][y] = 1

board

var i = 0, j = 0

mainloop:for i = 0; i<10; i++ {

    for j=0; j < 10; j++ {

        if board[i][j] == 1 {

            break mainloop

        }

    }

}

println("\(i)-\(j)")