更新：2018.05.24
整理了一下demo：SwiftDemo
Swift类是构造代码的一种通用而灵活的构造体。
- Swift中，用
类来描述对象，什么是类？拿人类来举例，整个人类就相当于一个类，这些不同的人类各不相同，而又有一些共同点，比如如都是直立行走，都会吃饭睡觉等等等等。每一个人类就是一个对象，而每一个人类是属于亚洲人种、欧洲人种、男人、女人、老人还是小孩，这就是一个人类的属性。每个人类都会有一些自己的行为，比如上班、做饭、旅游，这就是这个人类具有的方法。 - 通常来说，一个类的定义包含两部分内容，一部分是类的属性，另一部分是它所拥有的方法。例如人类：每个人类都有自己的名字、性别等，这是人类的属性，每个人类还拥有吃饭、睡觉、上班等行为。
- 类与结构体相似但不同，类和结构体都有属性，都可以定义方法，但类是引用类型，结构体是值类型。
- 与OC不同，Swift不要求你为自定义的类去创建独立的接口和实现文件，你所要做的就是在一个单一文件中定义一个类，系统会自动生成面向其他代码的外部接口。
1. 定义
与结构体的定义方法相同，类使用class关键字
class 类名 {
属性列表
方法列表
}
这里我们同样以人类为例，创建一个类：
class People {
var age:Int
var sex:String
var name:String
init() {
self.age = 0
self.sex = ""
self.name = ""
}
func introduce() {
print("My name is \(name), I`m a \(sex), \(age) years old.")
}
}
a -> 我们定义了一个类People，给People设置了三个属性:name、sex、age。
b -> Swift要求定义类时，类的属性一定要初始化，这里我加了一个init()方法初始化属性，当然也可以直接给属性赋值。
var age:Int = 0
var sex:String = ""
var name:String = ""
c -> 接着又给People添加了一个实例方法introduce，输出属性信息。
接下来让我们使用一下这个类
let people = People()
people.name = "LiLei"
people.sex = "boy"
people.age = 15
people.introduce()
#输出结果：
My name is LiLei, I`m a boy, 15 years old.
如果你觉得一个一个给属性赋值比较麻烦的话，也可以这样做：
class People {
var age:Int
var sex:String
var name:String
init() {
self.age = 0
self.sex = ""
self.name = ""
}
init(name:String, age:Int, sex:String) {
self.name = name
self.age = age
self.sex = sex
}
func introduce() {
print("My name is \(name), I`m a \(sex), \(age) years old.")
}
}
#调用
let people2 = People.init(name: "LiLei", age: 15, sex: "boy")
people2.introduce()
2. 类属性的 set 和 get 方法
相信OC中的set和get方法大家都很熟悉了，基本来说，set就是设置，get就是获取。
class Time {
var hour:Int = 1
var minute:Int {
get {
return self.hour * 60
}
set(newMinute) {
self.hour = newMinute/60
}
}
}
#调用
let time = Time()
print(time.hour)
print(time.minute)
#输出
1
60
a -> 在上面代码中，我们创建了一个Time的类，给它两个属性,hour和minute。
b -> 我们给hour了一个初始值 1 ，其中hour和minute是有换算关系的，所以我们为minute添加set和get方法。
c -> 当minute属性进行get操作时，返回hour乘以60之后的结果；当minute进行set操作时，同时设置hour的值为minute除以60后的结果。
d -> 输出：我们可以看到，hour的值依然是1，mintue的值是60。
如果我们给mintue赋值了呢？
time.minute = 360
print(time.hour)
print(time.minute)
#输出
6
360
e -> 可以看到，hour的值变成了6。
3. willSet和didSet
-
willSet和didSet属于给类属性添加观察者。 -
willSet在设置属性值之前被调用。 -
didSet在设置属性值之后被调用。 - 在实现
willSet时，新的属性值将被作为常量参数来传递，可以给这个参数一个名字，如果没有，这个参数就迷人被命名为newValue。
class Role {
var skill : Int = 1
var level : Int = 1 {
willSet {
print("角色即将升级，等级将要到达 \(newValue) ")
}
didSet {
if oldValue >= level {
print("升级失败!!!")
} else {
print("角色已经升级，等级到达 \(level)")
}
}
}
}
#调用
let role = Role()
role.level = 2
role.level = 2
#输出
角色即将升级，等级将要到达 2
角色已经升级，等级到达 2
角色即将升级，等级将要到达 2
升级失败!!!
a -> 在上面代码中，我们创建了一个Role的类，给它两个属性,level和skill。
b -> 我们为level添加了willSet和didSet方法。
c -> 在willSet方法中，调用此方法时，输出提示语，其中newValue是默认参数名。
d -> 在didSet方法中，调用此方法，判断level是否有增长,输出条件语句。oldValue是旧值的默认参数名。
4. 静态方法
- 静态方法，如果操作不需要具体实例，我们就可以定义近静态方法，反之，如果某些操作是需要具体实例的，那就需要定义实例化方法。
- 在OC中，我一般是叫类方法，比如封装网络请求时，一般是不需要实例的，就直接定义类方法。
- Swift中，可以为类、结构体和枚举定义静态方法，在为枚举和结果体定义静态方法时，使用关键字
static。为类定义静态方法时，使用class关键字。
class MathTool {
class func sum(number1:Int ,number2:Int) -> Int {
return number1 + number2
}
class func multiply(num1:Int ,num2:Int) -> Int {
return num1 * num2
}
}
#调用
print(MathTool.sum(number1: 10, number2: 1))
print(MathTool.multiply(num1: 2, num2: 4))
#输出
11
8
a -> 在上面代码中，创建了一个MathTool的类，并创建了两个静态方法sum和multiply。
b -> 调用的时候可以直接用类名调用，不需要实例化。如果某些地方不需要实例化，建议使用静态方法。
5. 类的析构
Swift和Object-C都是通过ARC来管理内存的，不需要我们对实例化的对象进行释放操作，但有些环境中，可能需要我们自己去清理一些额外的资源，比如创建了一个自定义的类，这个类打开了一个文件，并写入若干数据，就需要我们再类实例被释放之前关闭该文件。
class FileManager {
func openFile() {
print("open file from the resorce")
}
func writeFile() {
print("Write the data into the file")
}
deinit {
print("delete the fileManager")
}
}
#调用
var fileManager:FileManager? = FileManager()
fileManager?.openFile()
fileManager?.writeFile()
fileManager = nil
#输出
open file from the resorce
Write the data into the file
delete the fileManager
a -> 在上面例子中，我们定义了一个FileManager类，用于读取和编辑文件，并定义了两个方法openFile和writeFile。
b -> 在最后，添加了一个deinit，这个方法就是析构函数，当实例的引用计数为0时，系统自动调用这个方法，在输出结果中可以看出。
6. 继承
- 继承在OC中已经很常用了。在Swift中，继承是类所特有的，当一个类继承其他类时，继承类就称为子类，被继承的类称为父类或超类。
- 通过继承特性，子类可以使用父类的方法和属性以及下标脚本，也可以重写父类。
我们拿动物来举例：
class Animal {
func run() {
print("I can run")
}
}
a -> 我们创建了一个Animal的类，给它一个方法 run，然后我们去创建一个大象的子类。
class Elephant:Animal {
var name:String
override init() {
self.name = "elephant"
}
override func run() {
print("I'm a \(name), I can run.")
}
}
b -> 我们定义了一个子类 Elephant 请注意定义子类的写法，Elephant:Animal和OC的很像。
c -> 在子类中可以添加父类没有的方法或属性，这里添加了一个name属性并初始化。
d -> 请注意在init 和 run前面都有关键字 override。在重写一个父类的方法时，你需要在重写的方法前面加上override 关键字。如不使用的话，可能会出现各种错误，并且没有使用override关键字的重写，都被编译器诊断为错误。
如果不希望父类的属性、下标或方法被重写，可以在父类中的属性或方法前加final关键字，比如 final var、final func 等。
当子类中尝试重写 final方法或属性时，编译器将会编译错误。
7. 延时加载属性lazy
延时加载属性：当第一次被调用的时候，才对其进行初始化操作的属性。当一个类拥有一个重度且不经常使用的属性时，比如这个属性是一个复杂的类，初始化时会占用很多的资源，而这个属性当前并不是必须使用的，此时就可以在声明前加lazy关键字，添加一个延时加载，这样就可以使用时再去进行初始化操作，提高程序运行效率。
class Point {
var pointValue:String = "1000"
}
class UserInfo {
var username:String = "Coco"
lazy var point:Point = Point()
}
#调用
let user = UserInfo()
print(user.point.pointValue)
#输出
1000
a -> 首先我们定义了一个积分类Point，Point中有一个属性pointValue，然后定义了一个UserInfo类，有一个属性是Point类型，但我们并不是马上要使用这个属性，假设这个属性比较占用资源，所以在前面加了lazy关键字。
b -> 从图中我们可以看出，我们此时已经实例化了UserInfo类，
username属性有值，但point属性还是nil，并没有被实例化。
c -> 我们点击step over按钮往下走， point就不是nil了。
8. 类的引用特性
- Swift中，元组、枚举、结构体属于值类型，而类属于引用类型。
- 值类型的特征是在赋值、初始化和传递参数过程中的数据。并为这个数据创建一个崭新独立的实例。
- 引用类型与值类型不用，引用类型的实例在被赋予到一个变量或常量或作为参数传递到另一个函数时，其操作的并不是类实例的拷贝，而是已存在的实例本身。就是说，假如值类型和引用类型都是一个常量的话，值类型传递的是对这个常量进行拷贝得到的另一个常量，而引用类型传递的就是这个常量本身。
举例说明：
class Car {
var brand:String = "BMW"
}
#调用
let bmw = Car()
print(bmw.brand)
let toyota = bmw
toyota.brand = "toyota"
print(bmw.brand)
print(toyota.brand)
#输出
BMW
toyota
toyota
a -> 首先我们建立了一个Car类，里面有个属性brand，然后我们在viewDidLoad中实例化一个类实例，输出。
b -> 然后再创建一个常量 toyota等于bmw，并重新给brand赋值，然后输出。
c -> 从结果我们可以看出，brand属性的新值都是toyota。
9. 总结
好累呀，不想写了。
