本文接着上一篇，对Swift的结构体、类、协议、扩展、枚举以及闭包做一个简单的介绍。
七、结构体
Swift的结构体对比OC来说，可以添加初始化方法、可以遵守代理协议。
结构体的声明
格式：
struct + 结构体的名字 + {
声明成员变量（属性和方法）
}
声明一个结构体
struct Trainee {
//存储属性： 仅仅做储存值的作用
var name : String
var gender : String
var height : Float
var weight : Float
//计算属性： 通过计算获得自己的值
//设置属性的set和get方法
//属性里面的set方法不能单独存在，必须有一个同属性的get方法存在之后才可以写set方法
var bmi : Float {
get{
return weight / (height * height)
}
set{
self.bmi = newValue
}
}
//结构体属性
//结构体属性不能在普通的函数里面去调用
// static var condition : String? = nil
static var condition : String = "正常"
//init函数
init(name newName : String, gender newGender : String, height newHeight : Float, weight newWeight : Float) {
self.name = newName //函数内部使用内部参数名，不能使用外部参数名
self.gender = newGender
self.height = newHeight
weight = newWeight //如果不加self. 会默认为 self.weight
}
//Swift的结构体可以任意地创建函数
//成员方法（普通的函数）
func heheda() {
print("成员方法")
}
//如果需要在函数里面修改属性的值的话，需要在函数前面添加mutating关键字修饰
mutating func change() {
self.name = "🐒"
}
//结构体的类方法（结构体函数） 比成员方法多了static的修饰
static func introduce() {
self.name = "猿"
print(self.name)
}
//结构体函数里面不能调用普通的属性
//结构体函数里面可以调用结构体属性
//结构体函数里面可以调用一些本结构体存在的属性
static var talent : String? = nil
static func talentEvaluate(){
introduce()
self.talent = "Du bist nicht dumm"
print(talent)
//print(self.talent) //这两行打印效果一样
}
}
构造结构体的两种方式
var trainee : Trainee = Trainee.init(name: "Sven", gender: "male", height: 1.86, weight: 66)
print(trainee.bmi)
print(trainee.name)
var trainee1 : Trainee = Trainee(name: "Sven", gender: "male", height: 1.86, weight: 66)
print(trainee1.bmi)
调用结构体的成员方法
trainee.change()
print(trainee.name)
结构体的类方法用类名调用
Trainee.introduce()
Trainee.talentEvaluate()
八、类
Swift中用class来定义类
格式: class 关键字 + 类名 { 类的实现 }
class Person {
//在类里面创建一个属性的时候，必须有初值，如果不想设置初值，那么就设置成可选类型
var name : String? = nil
var age : Int? = nil
//private修饰的属性是私有属性
private var gender : String? = nil
//static修饰的属性是类属性
static var hobby : String? = nil
init(name newName : String, age newAge : Int){
name = newName
age = newAge
}
//实例方法里面不能直接调用类属性
//实例方法可以直接对实例对象进行修改赋值
func sayGender(){
self.gender = "女"
print(self.gender)
}
//在函数声明之前添加一个private 表示私有方法
private func showGender(){
self.gender = "女"
print(self.gender)
}
//static修饰的是类方法
//static修饰的类方法是不可以被子类重写的
static func sayHobby() {
self.hobby = "hiking"
print(self.hobby)
}
//class修饰的也是类方法
//class修饰的类方法可以被子类重写
class func showHobby() {
self.hobby = "Mounting"
print(self.hobby)
}
}
let person : Person = Person(name: "Silvia", age: 22)
person.sayGender()
person.showGender()
Person.sayHobby()
Person.showHobby()
class Designer: Person {
//如果想在子类中重写父类方法要加override修饰
override init(name newName: String, age newAge: Int) {
super.init(name: newName, age: newAge)
}
//这样会报错：
// override static func sayHobby() {
// }
override class func showHobby() {
}
}
九、协议
Swift里面协议中方法必须全部实现 OC有必须实现的方法和选择性实现的方法
格式:
protocol关键字 + 协议名字
protocol myDelegate{
//协议方法前面添加mutating修饰的关键字之后，可以修改结构体里面的参数，在类里面会自动地忽略mutating
mutating func letsGo()
// func keepMoving() -> String
}
//如果有需要可选实现的协议
//在最前面添加 @objc 修饰，内部的方法用optional修饰可选实现的方法，其他的不变 （这样变成了OC的协议）
@objc protocol newDelegate{
optional func heheda()
}
//如果一个类既有父类又遵守了某个协议，那么格式是
//class + 类名：父类，协议名字 如果有多个协议，协议之间用逗号隔开
class Engineer: Person, myDelegate, newDelegate {
func letsGo() {
}
}
class newClass: myDelegate {
func letsGo() {
}
}
//结构体可以遵守协议
//但是结构体只能遵守Swift的协议
struct newStruct : myDelegate {
var name : String
mutating func letsGo() {
self.name = "Stuttgart"
}
}
十、扩展
extension可以给一个类添加新的方法，但不可以添加新的属性
extension + 类名（结构体名字）可以对一个类和结构体扩展方法
extension可以多次对一个类进行扩展，也可以给一个类扩展协议方法
extension newStruct{
func park(){
print("park now")
}
}
let somebody = newStruct(name: "Silvia")
somebody.park()
extension可以给一个类拓展新的协议
//先声明一个名为MyProtocol的协议
@objc protocol MyProtocol {
optional func test1() //
func test2()
}
extension Engineer : MyProtocol {
@objc func test2() {
print("扩展新的协议")
}
}
let engineer = Engineer(name: "Lorraine", age: 22)
engineer.test2()
十一、枚举
Swift的枚举没有默认的0，1，2，3...
enum animal{
case cat
case tiger
case dog
case horse
}
//使用枚举的时候，初次给变量赋值，必须使用枚举名.case名
var animal1 = animal.cat
//第二次使用的时候，可以直接通过.case名使用
animal1 = .horse
switch搭配枚举使用
switch的value要填写一个枚举类型的实例变量
case .枚举的case名字
switch animal1 {
case .cat: //没代码提示，较容易出错
print("猫")
case .tiger:
print("虎")
case .dog:
print("🐶")
case .horse:
print("🐴")
}
十二、闭包
闭包是自包含的函数代码块，可以在代码中被传递和使用。
Swift中的闭包相当于C和OC中的block代码块，与其他一些编程语言中的匿名函数比较相似。（另：拆包是可选类型，与闭包不是一回事）
闭包可以捕获和存储其所在上下文中任意常量和变量的引用。这就是所谓的闭合并包裹着这些常量和变量，俗称闭包。Swift会管理在捕获过程中涉及到的所有内存操作。
闭包表达式格式：
闭包名字： ((参数) -> 返回值类型)
var newPassValue : ((a : Int, b : Int ) -> Int)
闭包有5种写法
//第一种闭包表达式的写法 （最全的写法）
newPassValue = { (a : Int, b : Int) -> Int in
return a > b ? a : b
}
//第二种写法 这是苹果推荐的写法
newPassValue = { (a , b) -> Int in
return a > b ? a : b
}
//第三种写法
newPassValue = {
$0 > $1 ? $0 : $1
}
//第四种写法
newPassValue = { (a , b) in
return a > b ? a : b
}
//第五种写法 （省略内容最多的一种）
newPassValue = { (a , b) in
a > b ? a : b
}
