第三周ios总结
字典与集合
1.字典
字典是存放键值对组合的容器
字典中每个元素都是由俩部分构成 冒号前面是键冒号后面是值
var dict: [String: String] = ["abacus": "算盘", "abnormal": "异常的", "hello" : "你好", "good": "好的"]
通过键获取对应的值（可空类型，因为给的键有可能没有与之对应的值）key--->value 如
print(dict["hello"]!)
print(dict["abcxyz"])
添加元素：
dict["shit"] = "狗屎"
dict["delicious"] = "好吃的"
删除元素：
dict.removeValueForKey("hello")
还有一种
dict["hello"]=nil
修改元素
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)")
}
2.集合
创建数组
var a :set = [1,2,4,1,2,5]
var b :set = [2,4,8,9,6]
注意：数组里可以有相同的元素 集合里 输出时相同的元素会合并
添加元素
a.insert(100)
删除元素
a.remove（2）
交集(a和b都有的元素)
a.intersect(b)
并集（aheb的所有元素）
a.union（b）
差集（a有b没有的元素）
a.subtract(b)
判断b是不是a的子集
b.isSubsetOf(a)
判断a是不是b的超集
a.isSupersetOf(b)
判断俩个集合是否相交
a.isDisjioinWith(b)
函数
定义函数：func 函数名(参数列表) -> 返回类型 { 函数的执行体 }
Swift中函数的参数可以设定默认值
如果调用函数的时候没有给该参数赋值就直接使用默认值ru如：
func sayHello(personName: String, alreadyGreeted: Bool = false) -> String {
if alreadyGreeted {
return "怎么又是你, " + personName + "!"
}
else {
return "你好, " + personName + "!"
}
}
调用函数：函数名(参数值)调用Swift的函数时, 在默认情况下从第二个参数开始需要写参数名
print(sayHello("王大锤", alreadyGreeted: true))
Swift中函数的参数列表可以是可变参数列表(参数的个数是任意多个)
func sum(nums: Int...) -> Int {
var total = 0
for num in nums {
total += num
}
return total
}
print(sum())
print(sum(999))
print(sum(1, 2, 3))
print(sum(90, 82, 37, 68, 55, 11, 99))
可以使用元组(tuple)让函数一次返回多条数据
func minMax(array: [Int]) -> (min: Int, max: Int)? {
if array.count == 0 {
return nil
}
var currentMin = array[0]
var currentMax = array[0]
for value in array[1.. currentMax {
currentMax = value
}
}
return (currentMin, currentMax)
}
if let b = minMax([23, 45, 99, 68, 72, 12, 55]) {
print(b.min)
print(b.max)
}
else {
print("数组中没有元素!!!")
}
func swap(inout a: Int, inout _ b: Int) -> Void {
(a, b) = (b, a)
inout - 输入输出参数(不仅将数据传入函数还要从函数中取出数据)
func createX(inout x: Int) {
x = 1000
}
inout类型的参数前要加上&符号
var x = 1
createX(&x)
print(x)
尾随闭包也叫匿名闭包
在Swift中函数是一种类型
这也就意味着函数可以作为变量或常量的类型
同理函数也可以作为另一个函数的参数或返回值
func foo(array: [Int], fn: (Int, Int) -> Int) -> Int {
var sum = array[0]
for x in array[1..当调用foo函数时第二个参数可以传什么?
- 所有自定义的(Int, Int) -> Int类型的函数
print(foo(a, fn: sum))
- 传入已有的二元运算符: +-*/%(因为运算符也是函数)
print(foo(a, fn: +))
- 传入匿名函数(闭包)
3.1 完整的闭包写法
print(foo(a, fn: { (a, b) -> 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 })
面向对象编程方法
面向对象的方法的步骤：
步骤1: 定义类(如果你要用的类苹果已经提供了就直接进入第2步)
定义类就可以创建出新的类型
如：学生类
class Student {
var name: String
var age: Int
init(name: String, age: Int) {
self.name = name
self.age = age
}
func eat() {
print("\(name)正在吃饭.")
}
｝
步骤2: 创建对象(调用初始化方法)
let stu1 = Student(name: "骆昊", age: 35)
步骤3: 给对象发消息(通过给对象发消息来解决问题)
stu1.eat()
运算符重载(为自定义的类型定义运算符)
func add(other: Fraction) -> Fraction {
return Fraction(num: _num * other._den + other._num * _den, den: _den * other._den)
}
func +(one: Fraction, two: Fraction) -> Fraction {
return one.add(two)
}
计算属性(通过对存储属性做运算得到的属性)
通常获得某个计算出的值的方法都可以设计成计算属性
var area: Double {
get { return M_PI * radius * radius }
}
}
继承与多态
继承
继承: 从已有的类创建新类的过程
提供继承信息的称为父类(超类/基类)
得到继承信息的称为子类(派生类/衍生类)
通常子类除了得到父类的继承信息还会增加一些自己特有的东西
所以子类的能力一定比父类更强大
继承的意义在于子类可以复用父类的代码并且增强系统现有的功能
如：父类person类
class Person {
var name: String
var age: Int
var gender: Gender
init(name: String, age: Int, gender: Gender) {
self.name = name
self.age = age
self.gender = gender
}
func eat() {
print("\(name)正在吃饭.")
}
}
子类teacher类
class Teacher: Person {
var title: String
init(name: String, age: Int, gender: Gender, title: String) {
self.title = title
super.init(name: name, age: age, gender: gender)
}
func teach(courseName: String) {
print("\(name)\(title)正在教\(courseName).")
}
}
多态
实现多态的关键步骤:
- 方法重写(子类在继承父类的过程中对父类已有的方法进行重写, 而且不同的子类给出各自不同的实现版本)
父类方法：
func shout() {
print("\(nickname)发出了叫声.")
}
子类重写父类方法
override func shout() {
print("\(nickname): 喵喵喵……")
}
```
2. 对象造型(将子类对象当成父类型来使用)
可以通过if+as?将父类型安全的转换成子类型然后再调用子类特有方法
for pet in petsArray {
pet.eat()
pet.play()
pet.shout()
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()
}
}