类与结构体的共同点：
- 定义属性用于存储值
- 定义方法用于提供功能
- 定义附属脚本用于访问值
- 定义构造器用于生成初始化值
- 通过扩展以增加默认实现的功能
- 实现协议以提供某种标准功能
与结构体相比，类还有如下的附加功能：
- 继承允许一个类继承另一个类的特征
- 类型转换允许在运行时检查和解释一个类实例的类型
- 解构器允许一个类实例释放任何其所被分配的资源
- 引用计数允许对一个类的多次引用
更多信息请参见继承，类型转换，析构过程，和自动引用计数。
注意
- 结构体总是通过被复制的方式在代码中传递，不使用引用计数。
<h3 id = "1">1.值类型与引用类型</h3>
值类型被赋予给一个变量、常量或者被传递给一个函数的时候，其值会被拷贝。
在之前的章节中，我们已经大量使用了值类型。实际上，在 Swift 中，所有的基本类型：整数（Integer）、浮点数（floating-point）、布尔值（Boolean）、字符串（string)、数组（array）和字典（dictionary），都是值类型，并且在底层都是以结构体的形式所实现。
在 Swift 中，所有的结构体和枚举类型都是值类型。这意味着它们的实例，以及实例中所包含的任何值类型属性，在代码中传递的时候都会被复制。
“与值类型不同，引用类型在被赋予到一个变量、常量或者被传递到一个函数时，其值不会被拷贝。因此，引用的是已存在的实例本身而不是其拷贝。”
var marray = ["lopl","liu","han"]
func modifyArray() {
var saray = marray
saray.removeAtIndex(2)
}
modifyArray()
marray//并没有变，说明是值拷贝
<h3 id = "2">2.将结构体实例赋值给一个常量，则无法修改结构体中的属性，即使属性是变量。</h3>
struct Cars {
var name = ""
}
let car = Cars()
car.name = "Audi"
//而类则可以修改，因为类是引用类型。
class CreateNewLife{
var name = ""
}
class Animals {
var kind = ""
let planet = "Earth"
lazy var createNewLife = CreateNewLife()
}
let life = CreateNewLife()
let anAnimal = Animals()
anAnimal.kind = "Human"
print(anAnimal,life)
if life === anAnimal {
print("same class")
}else{
print("Different class")
}
print(anAnimal.createNewLife.name)//这时CreateNewLife实例才会被创建
anAnimal.createNewLife.name = "liven"
print(anAnimal.kind,anAnimal.createNewLife.name)
<h3 id = "3">3.结构体和类中的属性定义-getter和setter</h3>
struct Point{
var x = 0.0,y = 0.0
}
struct Size {
var width = 0.0,height = 0.0
}
struct Rect {
var origin = Point()
var size = Size()
var center:Point{//计算属性:即写了get或set的属性。如果只有get，就是只读属性
get{
let centerX = origin.x + size.width/2
let centerY = origin.y + size.height/2
return Point(x: centerX, y: centerY)
}
set(newCenter){
origin.x = newCenter.x - size.width/2
origin.y = newCenter.y - size.height/2
}
}
var arcPoint:Point{//属性观察器didSet,willSet
willSet(newValue){//会将新的值传入
print("will set arcPoint \(newValue)")
}
didSet(oldValue){//会将旧的值传入
//arcPoint = Point(x: 8, y: 9)
print("did set arcPoint \(arcPoint) \(oldValue)")
}
}
static var name = "my rect"//Type property类型属性
//值类型属性一般不能在它自己的实例方法中修改；如果非要修改，需要加关键字mutating
mutating func bigger(x:Double,y:Double) {
size.width += x
size.height += y
}
}
Rect.name
Rect.name = "xxxx"
Rect.name
var rect = Rect(origin: Point(x: 10,y: 10), size: Size(width: 20,height: 30), arcPoint: Point(x: 1, y: 1))
print(rect.arcPoint)
rect.arcPoint = Point(x: 3, y: 4)
print(rect.arcPoint)
var rect2 = rect
rect2.arcPoint = Point(x: 6, y: 6)
print(rect.arcPoint,rect2.arcPoint)
rect.bigger(20, y: 20)
print(rect.size)
class SomeClass {
class var overrideProperty:Int{//get省略了。class关键字表示重写父类的getter实现
return 10
}
}
<h3 id = "4">4.方法</h3>
struct LevelTraker {
static var highestUnlockedLevel = 1
static func unlockLevel(level:Int){
if (level == highestUnlockedLevel + 1) {highestUnlockedLevel = level}
}
static func levelIsUnlocked(level:Int)->Bool{
return level <= highestUnlockedLevel
}
var currentLevel = 1
mutating func advanceLevel(level:Int)->Bool{
if LevelTraker.levelIsUnlocked(level) {
currentLevel = level
return true
}else{
return false
}
}
}
class Player {
var traker = LevelTraker()
var playerName:String
func completeLevel(level:Int) ->Bool{
LevelTraker.unlockLevel(level+1)
if traker.advanceLevel(level+1){
return true
}else{
print("Level \(level) hasn't been unlocked")
return false
}
}
init(name:String){
playerName = name
}
}
var level111 = LevelTraker()
var level121 = LevelTraker()
level121.currentLevel = 2
print(level111.currentLevel, level121.currentLevel)
var player = Player(name:"han")
player.traker.currentLevel
player.completeLevel(1)
player.traker.currentLevel
LevelTraker.highestUnlockedLevel
player.completeLevel(5)
<h3 id = "5">5.构造过程</h3>
class Cars{
var brand:String
var usage:String
//构造函数
init(){
brand = "BMW"
usage = "Family"
}
init(_brand:String,_usage:String){
brand = _brand
usage = _usage
}
}
let audi = Cars(_brand: "Audi", _usage: "Sports")
print(audi.brand,audi.usage)
let car2 = Cars()
print(car2.brand,car2.usage)
<h3 id = "6">6.当属性有默认值，且没有构造方法时，结构体和类拥有默认构造方法。但是结构体可以有带属性参数的默认构造方法（逐一成员构造器），而类没有。</h3>
struct People {
var name:String?
var sex:String?
}
class Books {
var type:String?
var category:String?
var available = true
}
let p = People()
let semdsd = People(name: "han", sex: "famale")
let book = Books()
//var book2 = Books(type:"epub",category:"Computer",available:true)
<h3 id = "7">7.析构过程</h3>
/**
- 析构器只适用于类类型，不能用于结构体。析构器用deinit关键字。
*/
class Telephones {
var type:String?
var category:String?
var available = true
init() {
//
}
deinit{
//析构代码。。。
print("\(type)")
available = false
}
}
/*
析构过程会在ARC回收实例时被系统调用，不需要手动调用。
*/
<h3 id = "8">8.类实例之间的循环强引用</h3>
解决方式：
1.使用weak关键字，弱引用
2.使用unowned，无主引用
<h3 id = "9">9.解决闭包引起的循环引用--定义捕获列表</h3>
protocol SellProducts{
func sellProducts(product:String)
}
class Person {
var name:String
weak var delegate:Seller?
lazy var someClosure:(Int,String)->String = {
//在闭包中将self修饰为无主引用。将delegate 修饰为 弱引用
[unowned self,weak delegate = self.delegate!]//捕获列表
(index:Int,strToProcess:String)->String in
return "\(self.name),\(self.delegate),\(delegate)"
}
init(name:String,delegate:Seller?){
self.name = name;
self.delegate = delegate;
}
func giveSellerProducts(product:String ) -> Bool {
self.delegate?.sellProducts(product)
return true
}
}
class Seller : SellProducts{
var product:String?
func sellProducts( product: String) {
self.product = product
}
}
let seller = Seller()
var person = Person (name: "Hanliu", delegate: seller)
//刚开始seller是没有商品的，要等到Person给seller
print(seller.product)
//person告诉seller，帮我卖苹果
person.giveSellerProducts("apple")
//现在seller手中就有了商品了
print(seller.product!)
person.someClosure(1,"haha")
