字典
字典是存放键值对组合的容器,字典中的每个元素都是由两部分构成的, 冒号前面是键冒号后面是值。
var dict: [String: String] = ["abacus": "算盘", "abnormal": "异常的", "hello" : "你好", "good": "好的"]
通过键获取对应的值(可空类型, 因为给的键有可能没有与之对应的值)
print(dict["hello"]!)
print(dict["abcxyz"])
输出结果为：
你好
nil
-
添加元素
dict["apple"] = ""
dict["delicious"] = "美味的"
print(dict)
-
删除元素
dict["hello"] = nil
或者
dict.removeValueForKey("hello")
-
修改元素
dict["shit"] = "牛粪"
print(dict)
-
遍历字典中所有的值
for value in dict.values {
print(value)
}
-
遍历字典中所有的键
for key in dict.keys {
print("\(key) ---> \(dict[key])")
}
-
直接通过一个元组获得字典中的键和值(原始类型)
for (key, value) in dict {
print("\(key) ---> \(value)")
}
函数
- 定义函数：
func 函数名(参数列表) -> 返回类型 { 函数的执行体 }
Swift中函数的参数可以设定默认值
如果调用函数的时候没有给该参数赋值就直接使用默认值
func sayHello(personName: String, alreadyGreeted: Bool = false) -> String {
if alreadyGreeted {
return "怎么又是你, " + personName + "!"
}
else {
return "你好, " + personName + "!"
}
}
- 调用函数
调用Swift的函数时, 在默认情况下从第二个参数开始需要写参数名,如果没有给第二个参数赋值那么就直接使用默认值false.
print(sayHello("王大锤", alreadyGreeted: true))
let str = sayHello("Jack")
print(str)
Swift中函数的参数列表可以是可变参数列表(参数的个数是任意多个)
func sum(nums: Int...) -> Int {
var total = 0
for num in nums {
total += num
}
return total
}
print(sum())
print(sum(999))
print(sum(90, 82, 37, 68, 55, 11, 99))
inout - 输入输出参数(不仅将数据传入函数还要从函数中取出数据)
func createX(inout x: Int) {
x = 1000
}
var x = 1
- 函数实例
设计一个函数传入两个正整数m和n, 计算从m加到n的和
func sum(m: Int, _ n: Int) -> Int {
let (a, b) = m > n ? (n, m) : (m, n)
var value = 0
for i in a...b {
value += i
}
return value
}
print(sum(1, 100))
实现函数的过滤，映射，缩减
- 过滤
let newArray1 = array.filter { $0 > 50 }
print(newArray1) - 映射
let newArray2 = array.map { $0 * $0 }
print(newArray2) - 缩减
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)
闭包
在Swift中函数是一种类型，这也就意味着函数可以作为变量或常量的类型，同理函数也可以作为另一个函数的参数或返回值。
func foo(array: [Int], fn: (Int, Int) -> Int) -> Int {
var sum = array[0]
for x in array[1.. let a = [1, 2, 3, 4, 5]
当调用foo函数时第二个参数可以传什么?
- 所有自定义的(Int, Int) -> Int类型的函数
print(foo(a, fn: sum)) - 传入已有的二元运算符: +-*/%(因为运算符也是函数)
print(foo(a, fn: +)) - 传入匿名函数(闭包)
闭包有多种写法 - 完整的闭包写法
print(foo(a, fn: { (a, b) -> Int in
return a + b - 省略掉类型和不必要的括号
print(foo(a, fn: { a, b in a + b })) - 省略参数名
print(foo(a, fn: { $0 + $1 })) - 尾随闭包
print(foo(a) { (a, b) -> Int in
return a + b
})
print(foo(a) { $0 + $1 })
面向对象
面向对象（OOP）是现代流行的程序设计方法，是一种主流的程序设计规范。其基本思想是使用对象、类、继承、封装、属性、方法等基本概念来进行程序设计。从现实世界中客观存在的事物出发来构造软件系统，并且在系统构造中尽可能运用人类的自然思维方式。
面向对象有三步：
步骤1: 定义类(如果你要用的类苹果已经提供了就直接进入第2步)，定义类就可以创建出新的类型
步骤2: 创建对象(调用初始化方法)
步骤3: 给对象发消息(通过给对象发消息来解决问题)
实例：
class Student {
// 变量定义到类的外面就叫变量 - variable
// 变量定义到类的里面就叫属性 - property
// 数据抽象 - 找到和学生相关的属性(找名词)
var name: String
var age: Int
// 初始化方法(构造方法/构造器) - constructor
init(name: String, age: Int) {
self.name = name
self.age = age
}
// 函数写到类的外面就叫函数 - function
// 函数写到类的里面就叫方法 - method
// 行为抽象 - 找到和学生相关的方法(找动词)
func eat() {
print("\(name)正在吃饭.")
}
func study(courseName: String) {
print("\(name)正在学习\(courseName).")
}
}
let stu1 = Student(name: "骆昊", age: 35)
stu1.eat()
stu1.study("Swift程序设计")
let stu2 = Student(name: "王大锤", age: 15)
stu2.eat()
stu2.study("中国近代史")
Swift中使用初始化方法来创建并初始化对象，我们可以在一个类中定义多个初始化方法，而且提供了一种叫做便利初始化方法（调用了其他的初始化方法的初始化方法）的语法，便利初始化方法会调用指派初始化方法来创建对象。
示例：
class Point {
var x: Double
var y: Double
// 便利初始化方法
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
}
func distanceTo(other: Point) -> Double {
let dx = x - other.x
let dy = y - other.y
return sqrt(dx * dx + dy * dy)
}
}
继承
在Swift中， 一个类可以继承另一个类的方法，属性和其它特性。当一个类继承其它类，继承类叫子类，被继承类叫父类。一旦某个类继承了它的父类，就同时有了父类的属性和方法。在子类中可以重写父类的方法也可以调用父类的方法。
class Cat: Pet {
// 父类有的方法子类可以重新实现，这个过程叫方法重写
// 需要在方法前添加override关键字
override func play() {
super.play() //调用父类方法
print("\(nickname)正在玩毛线球.")
}
override func shout() {
print("\(nickname): 喵喵喵……")
}
}
类扩展
如果在某个特定的应用场景中你发现现有的类缺少了某项功能，那么可以通过类扩展(extension)的方式现场添加这项功能
extension Point {
var cgPoint: CGPoint {
get { return CGPointMake(CGFloat(x), CGFloat(y)) }
}
}
多态
同样的对象类型(Pet类型)接收相同的消息(调用相同的方法)， 但是做了不同的事情 这就是多态(polymorphism)
- 方法重写(子类在继承父类的过程中对父类已有的方法进行重写, 而且不同的子类给出各自不同的实现版本)
- 对象造型(将子类对象当成父类型来使用)
let empsArray = [
Manager(name: "王大锤"),
Programmer(name: "余婷"),
Salesman(name: "广告莎")]
for emp in empsArray {
if let worker = emp as? Programmer {
print("请输入\(worker.name)本月工作时间: ", terminator: "")
worker.workingHour = inputInt()
}
else if let worker = emp as? Salesman {
print("请输入\(worker.name)本月销售额: ", terminator: "")
worker.sales = inputDouble()
}
print("\(emp.name)本月工资为: ￥\(emp.salary)元")
}
- 面向对象终极原则: 高内聚, 低耦合
面向对象七原则:
1. 单一职责原则(SRP)
2. 开闭原则(OCP)
3. 依赖倒转原则(面向抽象编程, DIP)
4. 里氏替换原则(LSP) - 能用父类型的地方就一定可以使用子类型
5. 接口隔离原则(ISP)
6. 合成聚合复用原则(CARP)
7. 迪米特法则(LoD)