枚举类型
swift中使用enum关键字声明枚举。并且可以指定枚举的类型
方式一、
enum Dirction : Int{
case east = 0
case west = 1
case north = 2
case south = 3
}
enum NethodType : String{
case get = "get"
case post = "post"
case put = "put"
case delete = "delete"
}
方式一枚举类型甚至可以为String类型。
方式二、
enum type : Int{ //这种方式只支持Int
case enum1 = 0,enum2,enum3,enum4,enum5
}
方式二对于枚举数量较多的情况下可以快速书写，但这种方式类型只支持Int
创建具体的枚举
第一种：
let type1 : NethodType = .get
第二种：
let type2 = NethodType.post
结构体
结构体定义格式如下：
struct 结构体名称 {
属性或方法
}
与oc不同，swift中结构体可以添加方法
定义结构体
struct location {
//属性
var x : Double
var y : Double
//方法
func test() {
print("结构体中的test方法")
}
}
结构体的构造函数
一般情况下，结构体为我们提供了默认的构造函数，需要我们为结构体中每一个属性赋值。但我们也可以自定义构造函数。
- 构造函数用init开头；
- 构造函数不需要返回值；
- 构造函数必须保证所有成员属性被初始化
在上面结构体中添加这个函数
假设我们需要传入一个string为10，20，将10赋值给x，将20赋值给y
init(xyStr : String) {
let array = xyStr.components(separatedBy: ",")
let item1 = array[0]
let item2 = array[1]
//?? 先判断前面可选类型是否有值， 有值系统解包，无值使用后面提供的值
self.x = Double(item1) ?? 0
self.y = Double(item2) ?? 0
}
改变成员属性
我们可以直接在函数中修改结构体中成员属性的值，但需要在函数前加上mutation关键字
mutating func moveH(distance : Double) {
self.x += distance
}
结构体的使用
//创建结构体对应值
var center = location(x: 20, y: 30)
//调用函数修改成员属性
center.moveH(distance: 20)
//使用自定义构造函数初始化
location(xyStr: "20,30")
swift中的类
类的定义格式
class 类名 : SuperClass {
//定义属性和方法
}
和结构体定义类似，但在swift中，类可以继承一个父类或者不继承，自己为根类。
类的定义
定义属性和方法
class Person {
//存储属性
var name : String = ""
var score1 : Double = 100
var score2 : Double = 88
var score3 : Double = 94
//计算属性--> 只读属性
var averageScore : Double {
return (self.score1 + self.score2 + self.score3) * 0.5
}
//类属性：和这个类相关，并且通过类名进行访问
static var courseCount : Int = 0
//函数
func getAverageScore() -> Double {
return (self.score1 + self.score2 + self.score3) * 0.5
}
}
与结构体一样，类中的成员变量需要先初始化。swift中的计算属性是只读属性，我感觉与oc中属性的get方法类似。oc还有类属性，直接与类关联，我们可以通过类名对它进行访问
var stu = Student()
//修改成员变量
stu.name = "zzq"
//获取只读属性
print(stu.averageScore)
//修改类属性
Student.courseCount = 3
类的属性监听器
当我们类中属性发生变化时，我们可以通过属性监听器来知道属性即将改变和已经改变，并作出相应处理
class Person {
//成员变量需要初始化
var name : String = "" {
//监听属性即将改变，还没改变
willSet {
print(newValue)
print("即将改变")
}
//监听属性已经改变
didSet {
print(oldValue)
print("发生改变")
}
}
}
在属性后使用括弧，使用willSet方法监听即将改变，didSet方法监听已经改变，默认情况下，willSet提供了newVlue参数告诉我们新的值是什么，didSet提供oldValue参数告诉我们旧的值是什么。
类的构造函数
与结构体一样，默认情况下系统会提供默认的构造函数，我们也可以自定义构造函数，当我们自定义构造函数后，默认的构造函数将无法使用，如果要使用，我们需要手动重写一下默认的构造函数。
//类的构造函数
class Person {
var name : String = ""
var age : Int = 0
//如果自定义构造函数，会覆盖系统提供的构造函数覆盖
init(name : String , age : Int) {
self.name = name;
self.age = age
}
//重写系统构造函数
init() {
}
}
使用KVC
KVC是oc中的一种特性，如果需要在swift类中使用KVC必须满足以下条件
- 继承NSObject类
- 先调用super.init()
- 如果字典中某key没有对应属性，需要重写setvalue forundefinekey方法
class Person : NSObject {
var name : String = ""
var age : Int = 0
//使用KVC
forundefinekey
init(dict : [String : Any]) {
super.init()
setValuesForKeys(dict)
}
override func setValue(_ value: Any?, forUndefinedKey key: String) {
}
}
通过KVC可以快速对类中成员变量进行初始化赋值。
析构函数
与oc类似，swift也是通过引用计数来判断对象声明周期的，当对象销毁时会调用类的析构函数。
class Person {
var name : String = ""
var age : Int = 0
//析构函数
deinit {
print("对象 销毁")
}
}
系统会默认生成析构函数，我们也可以重写deinit方法来处理一些事情
循环引用
与oc差不多，由于生命周期通过引用计数管理，当对象之间相互持有时会导致循环引用，出现内存无法释放的问题。
class Person {
var name : String = ""
var book : Book?
deinit {
print("person - deinit")
}
}
class Book {
weak var owner : Person?
deinit {
print("book - deinit")
}
}
var p : Person? = Person()
var b : Book? = Book()
p!.book = b
b!.owner = p
p = nil
b = nil
为了解决这个问题，我们可以在成员变量前添加weak关键字，这样就不会产品循环引用了。
可选链
在上一篇类型中我们已经知道，为了代码的严谨和安全，对所有可能为nil的对象都是可选类型。为了使用起来更加方便，swift提供了可选链方便我们调用。
class Person {
var name : String = ""
var dog : Dog?
}
class Dog {
var weight : Double = 0.0
var toy : Toy?
}
class Toy {
var price : Double = 0
func flying() -> Void {
print("飞")
}
}
let p = Person()
p.name = "zzq"
let d = Dog()
d.weight = 14
let t = Toy()
t.price = 100
p.dog = d
d.toy = t
//?.就是可选链，系统自动判断该可选类型是否有值，如果有值解包，没有赋值为nil
let price = p.dog?.toy?.price
p.dog?.toy?.flying()
我们可以通过 `?.的格式快速访问对象中的可选类型。并交给系统进行解包或赋值为nil
协议
协议的定义格式
protocol SprortProtocol {
func play1()
func play2()
}
在swift中默认情况下，如果遵守了协议，就必须实现协议中所有的方法。
class Teacher : SprortProtocol {
func play1() {
print("play1")
}
func play2() {
print("play2")
}
}
如果我们希望协议中的方法是选择实现的，我们需要使用到oc中的optional关键字，并且在协议和方法前添加@objc关键字
@objc protocol SprortProtocol {
@objc optional func play1()
func play2()
}
这样play1方法就不是必须要实现的了
给协议指定可遵守的类型
在swift中，类，结构体甚至是枚举都可以遵守协议。这就让我们的代码变得不那么严谨，我们可以在协议名后指定可遵守该协议的类型来让我们代码看起来更严谨。
protocol SprortProtocol: class {
func buy()
}
这样，就只有class可以遵守该协议了。这样写往往是用于我们的代理设计模式。
代理模式
protocol buyDelegate : class {
func buy()
}
class Person {
//定义代理属性
weak var delegate : buyDelegate?
func going() {
self.delegate?.buy()
}
}
为了防止循环引用，代理对象前最好添加weak关键字。