Swift day04 2016/1/21

今天去面试 ,没听课 ,根据上课讲得做下笔记.

1. 闭包,(类似 OC 中的 Block) 是将一段代码封装起来,变成一个类型变量的东西,可以作为参数传递,类似一个没有名字的函数. swift 中闭包就是函数,但比函数更加灵活.

//输入输出参数  (相当于地址传递)  选择
func selectSort(inout data : [Int], function : (Int,Int)->Bool ) {
    for var i = 0; i < data.count - 1;i++ {
        //记录最小下标
        var k = i  //假设 i 位置最小
        for var j = i + 1; j < data.count; j++ {
//            if data[j] > data[k] {
            if function(data[j], data[k]) {
                k = j
            }
        } //循环是找到最小的值的下标
        if k != i { //如果假设对了,不用交换
            swap(&data[k], &data[i])
        }
    }
}
//func rule(a : Int,_ b : Int) ->Bool {
//    return a > b
//}
//func rule2(a : Int,_ b : Int) ->Bool {
//    return a < b
//}
var data = [9, 3, 5, 1, 2, 6, 8, 7, 4, 3]
//selectSort(&data,function: rule2)
/*
语法:
    {
        (parameters 参数列表)->returnType返回值类型  in 
            code
        return xxxx
    }

*/
selectSort(&data, function:
    {
        (a : Int, b : Int)->Bool in
            return a > b
})
data
//闭包可以缩写 或 省略
//参数类型可以省略
selectSort(&data, function:
    {
        (a, b)->Bool in
        return a > b
})
//返回值类型可以省略
selectSort(&data, function:
    {
        (a, b) in
        return a > b
})
//如果只有一条语句  return 可以省略
selectSort(&data, function:{(a, b) in a > b })
//参数名可以省略  $0是传入的第一个参数  $1是传入的第二参数
selectSort(&data, function:{ $0 < $1 })
//甚至可以直接省略掉参数
selectSort(&data, function:>)

//map 方法, 把数组每个元素取出放到闭包函数中执行, 把所有的执行结果放到一个新的数组

var newNums = numbers.map({
    (number : Int) ->Int in
        var n = number + 20
    return n
})
//拖尾闭包, 如果一个函数的最后一个参数传入的是闭包函数,可以写在()外面,如果只有个一个参数() 可以省略
var newNums2 = numbers.map{
    (number : Int) ->Int in
    var n = number + 20
    return n
}

2.enum

枚举中可以有方法

enum ConpassPoint {
     case North
     case South
     case East
     case West
     func show(){
       print(self)
     }
}
var p = CompassPoint.North
p.show()


enum CompassPoint2{
    case North, South, East, West
}

//声明一个枚举变量
var point : CompassPoint
//给一个枚举变量初始化
point = CompassPoint.North
point = .South //没有枚举的名字,通过上下文环境找到对应的枚举



//原始值 (裸值)
enum Week : Int{
    case Sun = 0, Mon, Tur, Wen, Thu, Fri, Sat
}
// C 中可以 int week = Sun
//Swift 中 枚举值不能直接当做Int使用, 如果需要当做Int使用,可以使用枚举的原始值(裸值)
var week : Int = Week.Sun.rawValue //用原始值给 Int 赋值
var week2 : Week? = Week(rawValue: 0)



//关联值
enum Barcode {
    case UPCA(Int,Int,Int)  //条形码
    case QRCode(String)   //二维码
}
var barcode = Barcode.UPCA(690, 690740102, 2)
barcode = Barcode.QRCode("ajkdlsjflkdsjf")
switch barcode {
case Barcode.UPCA(let(num, id, check)):
    print("这是一个条形码\(num)-\(id)-\(check)")
case Barcode.QRCode(let string):
    print("这是一个二维码 对应的字符串是 \(string)")
}

3.类和结构体

相同点:
1.类和结构体都是在定义一种类型
2.都可以在内部定义属性和方法
3.都可以定义下标运算符
4.都可以定义初始化方法(初始化器, 构造器, init)
5.都可以扩展现有功能 (类似OC中Category 分类, swift中没有分类)
6.都可以遵守指定的协议
不同点:
1.类可以继承, 结构体不可以继承
2.类有多态, 结构体没有多态
3.类的内存管理支持自动引用计数器,而结构体的内存不使用引用计数器, 结构体的变量都是在栈中分配的,出了作用域会自动释放,栈中的空间不需要我们管理
4.类是引用类型, 结构体是值类型

//类中的属性声明时必须初始化, 除非它是可选值
class VideoMode {
    var resolution = Resolution()
    var interloaced = false
    var frameRate = 0.0
    var name : String? //可选值
}
//结构是值类型,类是引用类型
var res = Resolution() //值类型
var res2 = res
res.width = 500
res.width
res2.width
var vmode = VideoMode() //引用类型
var vmode2 = vmode
vmode.name = "张三"
vmode.name
vmode2.name
//实际上是比地址 === 相等 !== 不等
if vmode !== vmode2 {
    print("两个引用 引用了不是同一块地址")
}



var rect = Rect(origin: Point(x: 100, y: 100), size: Size(w: 500, h: 500))
print("矩形的原点x是\(rect.origin.x), y是\(rect.origin.y)")


//结构体是用来封装少量简单的数据
//最简单的像  几何图形  CGPoint CGRect CGSize
let cgPoint = CGPoint(x: 100, y: 200)

4.Properties属性

Swift属性 有两个分类方式
第一种分类方式 :
存储属性 (Stored Properties)
用变量或常量保存属性的值

计算属性 (Calculate Properties)
不用变量或常量保存属性值, 值是通过计算的出的

出生日期 : 储存属性
年龄 : 计算属性 是通过 当前日期 - 出生日期计算出来的

第二种分类方式:
实例属性 和 类型属性

属性的附加: 属性监视器 (properties observer)
用于探知属性的值是否发生了变化

struct FixedLengthRange {
    //存储属性  用一个变量或常量保存属性的值
    var firstValue : Int
    let length : Int //逐一初始化器 也可以给常量初始化
}
var flr = FixedLengthRange(firstValue: 0, length: 3)


class DataManager {
    //延迟属性  类似OC 中的懒加载 或 延迟加载的功能
    lazy var dataImporter = DataImporter()
    var data = [String]()
}

计算属性

/******* 计算属性  ***************/
struct Point{
    var x = 0.0, y = 0.0
}
struct Size {
    var w = 0.0, h = 0.0
}
struct Rect {
    //存储属性
    var origin = Point()
    var size = Size()
    //计算属性
    //只有get 是只读计算属性,  如果有get set 是可读写计算属性
    var center : Point {
        get{
            let centerX = origin.x + size.w * 0.5
            let centerY = origin.y + size.h * 0.5
            return Point(x : centerX,y : centerY)
        }
        set /*(newCenter) 如果这里没有任何接收 默认使用 newValue*/ {
            let newOriginx = newValue.x - size.w * 0.5
            let newOriginy = newValue.y - size.h * 0.5
            origin = Point(x: newOriginx, y: newOriginy)
        }
    }
    
    //计算属性 只读计算属性如果只有一行代码 get 可以省略
    var center2 : Point {
        /*get {*/
            return Point(x: 500 + 100, y: 500 + 100)
        /*}*/
    }
}
var rect = Rect(origin: Point(x: 0, y: 0), size: Size(w: 300, h: 300))
rect.center.x
rect.center.y
rect.center = Point(x :200, y : 200)
rect.origin.x
rect.origin.y