Swift3.0 - 真的很簡單
Swift3.0 - 數據類型
Swift3.0 - Array
Swift3.0 - 字典
Swift3.0 - 可選值
Swift3.0 - 集合
Swift3.0 - 流控制
Swift3.0 - 對象和類
Swift3.0 - 屬性
Swift3.0 - 函數和閉包
Swift3.0 - 初始化和釋放
Swift3.0 - 協議protocol
Swift3.0 - 類和結構體的區別
Swift3.0 - 枚舉
Swift3.0 - 擴展
Swift3.0 - 下標
Swift3.0 - 泛型
Swift3.0 - 異常錯誤
Swift3.0 - 斷言
Swift3.0 - 自動引用計數(strong,weak,unowned)
Swift3.0 - 檢測API
Swift3.0 - 對象的標識
Swift3.0 - 注釋
Swift3.0 - 元類型
Swift3.0 - 空間命名
Swift3.0 - 對象判等
Swift3.0 - 探究Self的用途
Swift3.0 - 類簇
Swift3.0 - 動態調用對象(實例)方法
Swift3.0 - 文本輸出
Swift3.0 - 黑魔法swizzle
Swift3.0 - 鏡像
Swift3.0 - 遇到的坑
必須知道的
共同點
a.定義存儲屬性
b.定義函數
c.定義下標,使用下表訪問自己的值
d.定義初始化設置自己的初始化狀態
e.擴展自己的功能
f.實現協議提供某種特定的標準功能不同點(類有更多功能)
a.類可以繼承,結構體不能繼承
b.類能夠在運行時檢查和解釋類實例的類型
c.Deinitializers使一個類的實例來釋放任何資源分配
d.類有引用計數,允許對象被多次引用
驗證
- 定義
// 定義類
class StudentC{
}
// 定義結構體
struct StudentS{
}
- 定義存儲屬性
// 定義類
class StudentC{
var name:String!
}
// 定義結構體
struct StudentS{
var name:String
}
提示:
在類中定義屬性必須要注意,如果你定義的存儲屬性不是可選值類型,必須進行初始化,不然編譯會報錯,但是結構體不會報錯,因為系統默認會給結構體創建初始化方法
- 定義函數
// 定義類
class StudentC{
static var des:String = "學生的類"
var name:String!
func getName()->String{
return name
}
class func describe()->String{
return des
}
static func getClassDescribe()->String{
return des
}
}
// 定義結構體
struct StudentS{
static var des:String = "學生的結構體"
var name:String
static func describe()->String{
return "這是一個定義學生的類"
}
}
提示:
類可以使用關鍵字static class 修飾方法,但是結構體只能使用關鍵字static修飾
- 擴展下標
class StudentC{
var names:[String] = ["1","2","3","4","5"]
subscript (index:Int)->String?{
get{
if names.count <= index{
return nil
}
return names[index]
}
}
}
// 定義結構體
struct StudentS{
var names:[String] = ["1","2","3","4","5"]
subscript (index:Int)->String?{
get{
if names.count <= index{
return nil
}
return names[index]
}
}
}
// 執行
let student1 = StudentC()
print(student1[8])
- 初始化
// 定義類
class StudentC{
var name:String
init( name:String) {
self.name = name
}
}
// 定義結構體
struct StudentS{
var name:String
init(name:String) {
self.name = name
}
}
let student1 = StudentC(name: "酷走天涯")
let student2 = StudentS(name: "XUJIE")
提示:
結構體默認會有初始化方法
struct StudentS{
var name:String
}
let student2 = StudentS(name: "xujie")
- 擴展功能
extension StudentC{
func describe()->String{
return "學生" + self.name
}
}
extension StudentS{
func describe()->String{
return "學生" + self.name
}
}
- 實現協議
// 定義一個協議
protocol Capacity{
func draw() // 協議方法
}
// 定義類
class StudentC:Capacity{
// 實現協議方法
internal func draw() {
}
var name:String
init( name:String) {
self.name = name
}
}
// 定義結構體
struct StudentS:Capacity{
// 實現協議方法
internal func draw() {
}
var name:String
}
- 繼承
// 定義基類
class Person{
var name:String
init( name:String) {
self.name = name
}
}
// 定義類
class StudentC:Person{
var score:Float
init( name:String,score:Float) {
self.score = score
super.init(name: name)
self.name = name
}
}
提示:
結構體不能繼承結構體
- mutating 關鍵字的作用
結構體和枚舉都是值類型,但是默認值類型的對象方法不能修改屬性值,但是要修改怎么辦呢?就必須在函數前面加mutating
//例子1
protocol Action{
var myY:Int{ mutating get}
}
struct Point{
var x:Int
var y:Int
// 結構體或者枚舉修改值必須在函數前面加mutating
mutating func modifyX(x:Int){
self.x = x
}
// 注意計算屬性,mutating 要加載getter方法前面
var myY:Int{
mutating get {
self.y = self.y*2
return y
}
}
}
// 例子2
struct Point {
var x = 0.0, y = 0.0
mutating func moveBy(x deltaX: Double, y deltaY: Double) {
self = Point(x: x + deltaX, y: y + deltaY)
}
}
// 例子3
enum TriStateSwitch {
case off, low, high
mutating func next() {
switch self {
case .off:
self = .low
case .low:
self = .high
case .high:
self = .off
}
}
}
提示:
1.計算屬性setter方法不用修改屬性值不用添加mutating
2.計算屬性setter方法中修改屬性值的時候,一定要加mutating
- 檢測兩個對象地址是不是相同
class StudentC{
var name:String
init( name:String) {
self.name = name
}
}
let student1 = StudentC(name: "xujie")
let student2 = student1
if student1 === student2{
print("地址相同")
}
運行結果:
地址相同
結論:
類是引用類型,結構體是值類型,不能使用===/!== 判斷地址
測試:
// 定義結構體
struct StudentS{
var name:String
}
let student1 = StudentS(name: "xujie")
var student2 = student1
student2.name = "酷走天涯"
print(student1.name)
print(student2.name)
運行結果:
xujie
酷走天涯
- Deinitializers使一個類的實例來釋放任何資源分配
// 定義類
class StudentC{
var name:String
init( name:String) {
self.name = name
}
deinit {
// 釋放資源
}
}
提示:
結構體沒有deinit 方法
高級話題
a. 什么時候用結構體
1.該結構的主要目的是封裝幾個相對簡單的數據值
2.如果你希望你的結構在傳遞的時候被賦值而不是引用
3.希望結構在傳遞的時候,內部的屬性也被復制而不是引用
4.不需要繼承屬性或者方法
主要應用場景(只包含非對象類型)
1.定義Size
2.定義范圍Range
3.定義坐標XYZ
...
b.什么時候用類
除了上面的場景外,其余都使用類對象。
官方建議:
define a class, and create instances of that class to be managed and passed by reference. In practice, this means that most custom data constructs should be classes, not structures.
用性能說話
測試1: 循環創建類和結構體
a.執行1億次類創建
// 定義類
class StudentC{
var name:String
init( name:String) {
self.name = name
}
}
// 統計時間
let date = Date()
for i in 0...100_000_000{
let s = StudentC(name: "酷走天涯")
}
print(Date().timeIntervalSince(date))
運行三次結果:
13.3261250257492
13.3587710261345
13.2861340045929
b.執行10億次結構體創建
// 定義結構體
struct StudentS{
var name:String
init( name:String) {
self.name = name
}
}
let date = Date()
for i in 0...1000_000_000{
let s = StudentS(name: "酷走天涯")
}
print(Date().timeIntervalSince(date))
運行三次結果:
6.93744301795959
7.18747901916504
7.20444202423096
我們上面的屬性為基本數據類型,我們將屬性改為對象測試一下速度
c.創建10_000_000個對象
class StudentC{
var date = NSDate()
}
for i in 0...10_000_000{
let s = StudentS()
}
測試結果:
3.38509398698807
3.4364920258522
3.39519000053406
d.創建10_000_000個結構體實例
struct StudentS{
var date = NSDate()
}
for i in 0...10_000_000{
let s = StudentS()
}
測試結果:
2.04776203632355
2.03975200653076
1.98246997594833
結論:
創建結構體要比創建對象速度快
測試2:創建1000_000 個對象或者結構體放在數組中,查看內存占用率
a.循環創建1000_000個對象
class StudentC{
var name:String
init( name:String) {
self.name = name
}
}
var students:[StudentC] = []
// 創建
for i in 0...1000_000{
let s = StudentC(name: "酷走天涯")
students.append(s)
}
運行結果:
內存占用61.8MB
b.循環創建1000_000個結構體
struct StudentS{
var name:String
init( name:String) {
self.name = name
}
}
var students:[StudentS] = []
for i in 0...1000_000{
let s = StudentS(name: "酷走天涯")
students.append(s)
}
運行結果:
內存占用32.6MB
照樣,我們將基本屬性改為對象繼續測試
c.10_000_000 個對象添加到數組中
class StudentC{
var date = NSDate()
}
var students:[StudentC] = []
for i in 0...10_000_000{
let s = StudentC()
students.append(s)
}
測試結果:
占內存538.7MB
d.10_000_000 個結構體添加到數組中
struct StudentS{
var date = NSDate()
}
for i in 0...10_000_000{
let s = StudentS()
students.append(s)
}
測試結構:
占用225.7MB
結論:
創建相同屬性的結構體比類更加節省內存
- 對1_000_000個結構體實體和對象進行排序,測消耗時間
a.對1_000_000個結構體實體進行排序
let date = Date()
students.sort { (stu1, stu2) -> Bool in
return stu1.name > stu2.name
}
print(Date().timeIntervalSince(date))
運行結果:
13.3783949613571
13.6793909668922
b.對1_000_000個對象進行排序
let date = Date()
students.sort { (stu1, stu2) -> Bool in
return stu1.name > stu2.name
}
print(Date().timeIntervalSince(date))
運行結果:
6.70881998538971
6.60394102334976
結論: 在數據量比較大的排序中,結構體排序的速度比較慢,因為結構體是值類型,排序的時候,需要大量的賦值運算。而對象只需要交換地址即可。
綜合建議:
結構體創建速度,內存占用更小,如果需要使用復雜的運算,這個時候,就需要綜合考慮兩者的有缺點了。
