Swift第三周总结

swift第三周总结

字典

var dict: [String: String] = ["abacus": "算盘", "abnormal": "异常的", "hello" : "你好"]
// 通过键获取对应的值(可空类型, 因为给的键有可能没有与之对应的值)
print(dict["hello"]!)
// 添加元素
dict["shit"] = "狗屎"
// 删除元素
// dict.removeValueForKey("hello")
// 修改元素
dict["shit"] = "牛粪"
// 遍历字典中所有的值
for value in dict.values {
    print(value)
}
// 遍历字典中所有的键
for key in dict.keys {
    print("\(key) ---> \(dict[key])")
}
// 直接通过一个元组获得字典中的键和值(原始类型)
for (key, value) in dict {
    print("\(key) ---> \(value)")
}

函数

函数有外部变量名和内部变量名

// inout - 输入输出参数(不仅将数据传入函数还要从函数中取出数据)
func createX(inout x: Int) {
    x = 1000
}
var x = 1
// inout类型的参数前要加上&符号
createX(&x)
print(x)
// 一般的函数调用传参都是传值
// 在Swift中函数是一种类型
// 这也就意味着函数可以作为变量或常量的类型
// 同理函数也可以作为另一个函数的参数或返回值
func foo(array: [Int], fn: (Int, Int) -> Int) -> Int {
    var sum = array[0]
    for x in array[1.. Int in
    return a + b
}))
// 3.2 省略掉类型和不必要的括号
print(foo(a, fn: { a, b in a + b }))
// 3.3 省略参数名
print(foo(a, fn: { $0 + $1 }))
// 3.4 尾随闭包
print(foo(a) { (a, b) -> Int in
    return a + b
})
print(foo(a) { $0 + $1 })

数组中字符串长度排序（闭包）

var array = ["game", "abacus", "hello", "cat", "good", "internationalization", "chaos", "dislike", "zealot", "young"]

// array.sortInPlace(>)
array.sortInPlace({ $0 > $1 })
// array.sortInPlace() { $0 > $1 }
// array.sortInPlace { $0 > $1 }
// 如果函数的最后一个参数是闭包可以写成尾随闭包的形式
// 也就是将闭包放到函数参数的圆括号外面写在一对花括号中
// 如果函数后面有尾随闭包且函数的圆括号中没有参数
// 那么函数的圆括号也可以省略(仅限于有尾随闭包的场景)
array.sortInPlace {
    if $0.characters.count == $1.characters.count {
        return $0 < $1
    }
    return $0.characters.count < $1.characters.count
}

数组中三个重要的方法（比较牛B）

let array = [23, 37, 96, 55, 40, 92, 68, 88]
// 1. 过滤
let newArray1 = array.filter { $0 > 50 }
// 2. 映射
let newArray3 = array.map { $0 * $0 }
// 3. 缩减(返回任意类型)最终返回一个东西
求和
let result1 = array.reduce(0, combine: +)
print(result1)

let result2 = array.reduce(1, combine: *)
print(result2)
let result3 = array.reduce(array[0]) {
    $1 > $0 ? $1 : $0
}
print(result3)
数组中字符串查空格
let strArray = ["I", "love", "you"]
let result4 = strArray.reduce("") { $0 + " " + $1 }
print(result4)

便利构造器

// 便利初始化方法 / 便利构造器
    // 调用了其他的初始化方法的初始化方法
    convenience init() {
        self.init(x: 0, y: 0)
    }
    convenience init(point: (Double, Double)) {
        self.init(x: point.0, y: point.1)
    }
    // 指派初始化方法 / 指派构造器
    // 被其他初始化方法调用的初始化方法
    init(x: Double, y: Double) {
        self.x = x
        self.y = y
    }

访问修饰符。计算属性

// 存储属性通常是private的 因为数据要保护起来
// 方法一般是public的 因为方法是对象接受的消息
// 如果自定义的类没有打算在其他项目中使用 可以不写访问修饰符
// 直接使用默认的internal修饰符表示在本项目中公开对其他项目私有
// - public (公开)
// - internal (内部的) - 默认
// - private (私有)

    // stored property
    // 存储属性(保存和圆相关的数据的属性)
    var center: Point
    var radius: Double
    init(center: Point, radius: Double) {
        self.center = center
        self.radius = radius
    }
    // 通常获得某个计算出的值的方法都可以设计成计算属性
    // computational property
    // 计算属性(通过对存储属性做运算得到的属性)
    var perimeter: Double {
        // 圆的周长是一个只读属性
        // 所以此处只有get{}没有set{}
        get { return 2 * M_PI * radius }
    }
    var area: Double {
        get { return M_PI * radius * radius }
    }
}
/*********************************************/
    private var _name: String
    private var _hp: Int
    private var _mp: Int
    var name: String {
        get { return _name }
    }
    var hp: Int {
        get { return _hp }
        set { _hp = newValue > 0 ? newValue : 0 }
    }
    var mp: Int {
        get { return _mp }
    }

类扩展方法

// 如果在某个特定的应用场景中你发现现有的类缺少了某项功能
// 那么可以通过类扩展(extension)的方式现场添加这项功能
extension Point {
    var cgPoint: CGPoint {
        get { return CGPointMake(CGFloat(x), CGFloat(y)) }
    }
}
extension CGPoint {
    var myPoint: Point {
        get {
            return Point(x: Double(self.x), y: Double(self.y))
        }
    }
}

extension UIColor {
    static func randomColor() -> UIColor {
        let r = CGFloat(randomInt(0, 255)) / 255.0
        let g = CGFloat(randomInt(0, 255)) / 255.0
        let b = CGFloat(randomInt(0, 255)) / 255.0
        return UIColor(red: r, green: g, blue: b, alpha: 1)
    }
}

贝塞尔曲线画法

func draw() {
        let bezierPath = UIBezierPath()
        bezierPath.moveToPoint(va.cgPoint)
        bezierPath.addLineToPoint(vb.cgPoint)
        bezierPath.addLineToPoint(vc.cgPoint)
        bezierPath.addLineToPoint(va.cgPoint)
        // bezierPath.closePath()
        // bezierPath.fill()
        // 如果color为nil就取??后面的值
        // 如果color不为nil就直接使用color的值
        (color ?? UIColor.blueColor()).set()
        bezierPath.fill()
    }

屏幕点击

    var pointsArray: [Point] = []
    var trisArray: [Triangle] = []
    override func touchesBegan(touches: Set, withEvent event: UIEvent?) {
        if let touch = touches.first {
            let touchPoint = touch.locationInView(self)
            pointsArray.append(touchPoint.myPoint)
            if pointsArray.count == 3 {
                let t = Triangle(va: pointsArray[0], vb: pointsArray[1], vc: pointsArray[2])
                t.color = UIColor.randomColor()
                trisArray.append(t)
                setNeedsDisplay()
                pointsArray.removeAll()
            }
        }
    }

短除法

// 短除法(欧几里得算法)
// x和y的最大公约数跟y%x和x的最大公约数是一样的
// Greatest Common Divisor
func gcd(x: Int, _ y: Int) -> Int {
    if x > y {
        return gcd(y, x)
    }
    else if y % x != 0 {
        return gcd(y % x, x)
    }
    else {
        return x
    }
}

开火车方法：

函数返回一个对象，可以连续的调方法

枚举

enum Direction: Int {
    case Up, Right, Down, Left
}

// GET: 枚举是定义符号常量的最佳方式
// GET: 符号常量总是优于字面常量
/**
 花色的枚举
 
 - Spade:   黑桃
 - Heart:   红心
 - Club:    草花
 - Diamond: 方块
 */
enum Suite: String {
    case Spade = "♠️"
    case Heart = "❤️"
    case Club = "♣️"
    case Diamond = "♦️"
}

继承

// 继承: 从已有的类创建新类的过程
// 提供继承信息的称为父类(超类/基类)
// 得到继承信息的称为子类(派生类/衍生类)
// 通常子类除了得到父类的继承信息还会增加一些自己特有的东西
// 所以子类的能力一定比父类更强大
// 继承的意义在于子类可以复用父类的代码并且增强系统现有的功能
class Teacher: Person
// 父类有的方法子类可以重新实现 这个过程叫方法重写
// 需要在方法前添加override关键字
// 重写有时也被称为置换/覆盖/覆写

多态

// 学生是人, 老师是人, 所以学生和老师的对象可以赋值给人类型的变量
let p2: Person = Student(name: "张尼玛", age: 18, gender: .Female, major: "计算机科学与技术")
p2.eat()
// 如果要将父类型的变量转换成子类型需要用as运算符进行类型转换
// 如果能够确认父类型的变量中就是某种子类型的对象可以用as!进行转换
// 如果不确定父类型的变量中是哪种子类型可以用as?尝试转换
(p2 as! Student).study("Swift程序设计")
if let temp = p2 as? Teacher {
    temp.teach("Java")
}
else {
    print("\(p2.name)不是老师!!!")
}

多态用法（同样的对象类型(Pet类型)调用相同的方法，但是做了不同的事情）

let petsArray = [
    Cat(nickname: "加菲", gender: .Female, age: 2),
    Dog(nickname: "旺财", gender: .Male, age: 3, isLarge: true),
    Dog(nickname: "大黄", gender: .Male, age: 1, isLarge: false),
    Mistress(nickname: "小美", gender: .Female, age: 24)
]

for pet in petsArray {
    pet.shout()
    // 同样的对象类型(Pet类型)接收相同的消息(调用相同的方法)
    // 但是做了不同的事情 这就是多态(polymorphism)
    // 实现多态的关键步骤: 
    // 1. 方法重写(子类在继承父类的过程中对父类已有的方法进行重写, 而且不同的子类给出各自不同的实现版本)
    // 2. 对象造型(将子类对象当成父类型来使用)
    
    // 可以通过if+as?将父类型安全的转换成子类型然后再调用子类特有方法
    if let dog = pet as? Dog {
        dog.keepTheDoor()
    }
    else if let cat = pet as? Cat {
        cat.catchTheMouse()
    }
    else if let mis = pet as? Mistress {
        mis.makeTrouble()
    }
}