[TOC]
字典集合
字典：字典(存放键值对组合的容器)字典中的每个元素都是由两部分构成的, 冒号前面是键冒号后面是值
集合：Swift中的Set类型被写为Set<T>,这里的T表示Set中允许存储的类型。
var dict: [String: String] = ["a": "你", "b": "好"]
通过键获取对应的值(可空类型, 因为给的键有可能没有与之对应的值)
print(dict["hello"]!)// key ---> value
print(dict["abcxyz"])
元素的添加修改删除
dict["c"] = "吗"// 添加元素
dict.removeValueForKey("hello")// 删除元素
dict["hello"] = nil //删除元素的值
dict["c"] = "你好" //元素值的修改
遍历
for value in dict.values {
print(value)// 遍历字典中所有的值
}
for key in dict.keys {
print("\\(key) ---> \\(dict[key])") //遍历字典中所有的键
}
for (key, value) in dict {
print("\\(key) ---> \\(value)")// 直接通过一个元组获得字典中的键和值(原始类型)
}
集合的创建
var a: Set<Int> = [1, 2, 3, 4, 2, 5]
集合元素的修改
a.insert(100) // 添加元素
a.remove(2) // 删除元素
集合的操作
var b: Set<Int> = [3, 5, 7, 9, 11]
var a: Set<Int> = [1, 2, 3, 4, 2, 5]
print(a.intersect(b)) // 交集(a和b都有的元素)
print(a.union(b)) // 并集(a和b的所有元素)
print(a.subtract(b)) // 差集(a有b没有的元素)
let c: Set<Int> = [1, 3]
print(c.isSubsetOf(a)) // 判断c是不是a的子集
print(a.isSupersetOf(c)) // 判断a是不是c的超集
let d: Set<Int> = [2, 1000, 10000]
print(a.isDisjointWith(d)) // 判断两个集合是否相交
函数
定义函数：func 函数名(参数列表) -> 返回类型 { 函数的执行体 }
Swift中函数的参数可以设定默认值 如果调用函数的时候没有给该参数赋值就直接使用默认值
func sayHello(personName: String, alreadyGreeted: Bool = false) -> String {//Bool 默认值是false ->返回的类型
if alreadyGreeted {
return "你好, " + personName + "!"
}
函数的参数名：函数名(外部参数名 内部参数名: 类型, 外部参数名 内部参数名: 类型)
如果不写外部参数名那么内部参数名也是外部参数名
可以使用_来作为外部参数名表示省略外部参数名
func myMin(a x: Int, b y: Int) -> Int {//a,b外部参数名 x，y内部参数名
return x < y ? x : y
}
调用函数的时候要写函数的外部参数名
print(myMin(a: 3, b: 5))
调用函数： 函数名(参数值)， 调用Swift的函数时, 在默认情况下从第二个参数开始需要写参数名
print(sayHello("小明", alreadyGreeted: true))
如果没有给第二个参数赋值那么就直接使用默认值false
print(sayHello("Jack")
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))
在Swift中函数是一种类型,这也就意味着函数可以作为变量或常量的类型,同理函数也可以作为另一个函数的参数或返回值
func foo(array: [Int], fn: (Int, Int) -> Int) -> Int {
var sum = array[0]
for x in array[1..<array.count] {
sum = fn(sum, x)
}
return sum
}
闭包
闭包：闭包是功能性自包含模块，可以在代码中被传递和使用
传入匿名函数(闭包)
如果函数的最后一个参数是闭包可以写成尾随闭包的形式
也就是将闭包放到函数参数的圆括号外面写在一对花括号中
如果函数后面有尾随闭包且函数的圆括号中没有参数
那么函数的圆括号也可以省略(仅限于有尾随闭包的场景)
1.1 完整的闭包写法
print(foo(a, fn: { (a, b) -> Int in
return a + b
}))
1.2 省略掉类型和不必要的括号
print(foo(a, fn: { a, b in a + b }))
1.3 省略参数名
print(foo(a, fn: { $0 + $1 }))
1.4 尾随闭包
print(foo(a) { (a, b) -> Int in
return a + b
})
类
类
发现类
- 在对问题的描述中找名词和动词
- 名词会成为类或者类中的属性 动词会成为类中的方法
定义类
- 数据抽象(属性)
- 行为抽象(方法)
- 初始化方法
访问修饰符
public (公开)
internal (内部的) - 默认
private (私有)
存储属性通常是private的 因为数据要保护起来
方法一般是public的 因为方法是对象接受的消息
如果自定义的类没有打算在其他项目中使用 可以不写访问修饰符
直接使用默认的internal修饰符表示在本项目中公开对其他项目私有
class Circle {
// 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 }
}
}
步骤1: 定义类(如果你要用的类苹果已经提供了就直接进入第2步)
定义类就可以创建出新的类型
例：学生类
class Student {
// 变量定义到类的外面就叫变量 - variable
// 变量定义到类的里面就叫属性 - property
// 数据抽象 - 找到和学生相关的属性(找名词)
var name: String
var age: Int
// 初始化方法(构造方法/构造器) - constructor
init(name: String, age: Int) {
self.name = name
self.age = age
}
// 我们可以在一个类中定义多个初始化方法
// 便利初始化方法 / 便利构造器
// 调用了其他的初始化方法的初始化方法
convenience init(s:(String,Int)) {
self.init(name: s.0, age: s.1)
}
convenience init() {
self.init(name: s.0, age: s.1)
}
// 指派初始化方法 / 指派构造器
// 被其他初始化方法调用的初始化方法
init(x: Double, y: Double) {
self.x = x
self.y = y
}
// 函数写到类的外面就叫函数 - function
// 函数写到类的里面就叫方法 - method
// 行为抽象 - 找到和学生相关的方法(找动词)
func study(courseName: String) {
print("\\(name)正在学习\\(courseName).") }
}
}
步骤2: 创建对象(调用初始化方法)
let stu1 = Student(name: "小明", age: 35)
步骤3: 给对象发消息(通过给对象发消息来解决问题)
tu1.study("Swift程序设计")
短除法(欧几里得算法)
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 Gender { //枚举
case Male
case Female
}
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)正在吃饭.")
}
}
创建子类
class Student: Person {//:Person 继承人类（父类）
var major: String//课程
init(name: String, age: Int, gender: Gender, major: String) {
self.major = major
super.init(name: name, age: age, gender: gender)
}
func study(courseName: String) { //学生学习的方法
print("\\(name)是\\(major)专业的学生.")
print("\\(gender == .Male ? "他" : "她")正在学习\\(courseName).")
}
}
创建对象
let per = Person(name: "小明", age: 25, gender: .Male)//创建小明
p1.eat()
可以将子类型的对象赋值给父类型的变量(因为子类跟父类之间是IS-A关系)
学生是人, 老师是人, 所以学生和老师的对象可以赋值给人类型的变量
let student: Person = Student(name: "张三", age: 18, gender: .Female, major: "计算机科学与技术")//创建学生张三
student.eat()//继承父类吃饭的方法
如果要将父类型的变量转换成子类型需要用as运算符进行类型转换
如果能够确认父类型的变量中就是某种子类型的对象可以用as!进行转换
如果不确定父类型的变量中是哪种子类型可以用as?尝试转换
(p2 as! Student).study("Swift程序设计")
if let temp = p2 as? Teacher {
temp.teach("Java")
}
else {
print("\\(p2.name)不是老师!!!")
}
面向对象
终极原则: 高内聚, 低耦合
面向对象七原则:
- 单一职责原则(SRP)
- 开闭原则(OCP)
- 依赖倒转原则(面向抽象编程, DIP)
- 里氏替换原则(LSP) - 能用父类型的地方就一定可以使用子类型
- 接口隔离原则(ISP)
- 合成聚合复用原则(CARP)
- 迪米特法则(LoD
GoF设计模式 - 23种设计模式
多态
同样的对象类型(Pet类型)接收相同的消息(调用相同的方法)
但是做了不同的事情 这就是多态(polymorphism)
实现多态的关键步骤:
1.方法重写(子类在继承父类的过程中对父类已有的方法进行重写, 而且不同的子类给出各自不同的实现版本)
2.对象造型(将子类对象当成父类型来使用)
可以通过if+as?将父类型安全的转换成子类型然后再调用子类特有方法
例 首先创建动物父类
class Pet {
var nickname: String
var gender: Gender
var age: Int
init(nickname: String, gender: Gender, age: Int) {
self.nickname = nickname
self.gender = gender
self.age = age
}
func play() {
print("\\(nickname)正在玩耍.")
}
func shout() {
print("\\(nickname)发出了叫声.")
}
}
创建子类 猫
// Cat和Pet之间是IS-A关系(继承)
class Cat: Pet {
var hairColor: String?
// 父类有的方法子类可以重新实现 这个过程叫方法重写
// 需要在方法前添加override关键字
// 重写有时也被称为置换/覆盖/覆写
override func play() {
print("\\(nickname)正在玩毛线球.")
}
override func shout() {
print("\\(nickname): 喵喵喵……")
}
}
创建子类 狗
class Dog: Pet {//继承动物类
init(nickname: String, gender: Gender, age: Int) {
super.init(nickname: nickname, gender: gender, age: age)
}
override func play() {//重写玩耍的方法
print("\\(nickname)正在接飞碟.")
}
override func shout() {//重写叫的方法
print("\\(nickname): 旺旺旺……")
}
}
创建 猫，狗
let petsArray = [
Cat(nickname: "加菲", gender: .Female, age: 2),
Dog(nickname: "旺财", gender: .Male, age: 3, )
]
for pet in petsArray {
pet.eat()
pet.play()
}
运行结果：
