Swift-初始化-initialize

import UIKit

 

//为储值属性设置默认值或在构造器(init)中为其赋值时，是不会触发属性观察的。

 

 

struct Color {

   var color: String

}

 

class Car {

   var paintColor: Color

   func fillGasTank() {}

   init(CarColor: Color) {

       paintColor = CarColor

        fillGasTank()

    }

}

 

class RaceCar: Car {

   var hasTurbo: Bool

   override func fillGasTank() {

        println("fillGasTank")

    }

   init(RaceCarColor: Color, turbo: Bool) {

       hasTurbo = turbo

       super.init(CarColor: RaceCarColor)

    }

    

    //关键字convenience必须写

    convenience init(_RaceCarColor1: Color) { //使用"_"表示不适用外部名称

       self.init(RaceCarColor:RaceCarColor1, turbo:true)

    }

    

    convenience init() {

        self.init(Color(color: "灰色"))

    }

}

 

let赛车1 = RaceCar()

let 赛车2 = RaceCar(Color(color: "蓝色"))  //(RaceCarColor1:Color(color: "蓝色"))

let赛车3 = RaceCar(RaceCarColor: Color(color: "红色"), turbo: true)

 

class FormulaOne: RaceCar {

   let minimumWeight = 642

    

    init(FormulaOnecolor color: Color) {//可以定义外部参数名（这里是FormulaOnecolor），但是在构造方法里只能使用内部参数名

       super.init(RaceCarColor: color, turbo: false)

    }

}

let方程式赛车1 = FormulaOne(FormulaOnecolor: Color(color: "白色"))

 

//========延迟加载属性========

//延迟加载属性必须有初始化方法

class DataImporter{

   /*

    DataImporter 是一个将外部文件中的数据导入的类

    这个类的初始化会消耗不少时间

   */

   var fileName = "data.txt"

    //这是提供数据导入功能

}

class DataManager {

    lazy var importer = DataImporter() //新版的lazy前面不用@

   var dataname : String?

   var data1 = [String]()

   var data2:[String]=[]

    //这是提供数据管理功能

}

let manager = DataManager()

manager.data1 += ["Some data"]

manager.data2.append("Moredata")

//DataImporter的实例importer还没有被创建

manager.importer //这时才用到

 

 

//值类型的构造器代理

struct Size{

   var width = 0.0, height = 0.0

}

struct Point {

   var x = 0.0, y = 0.0

}

struct Rect {

   var origin = Point()

   var size = Size()

    init(){} //origin和size都是用默认值

   init(origin: Point, size: Size){

       self.origin = origin

       self.size = size

    }

   init(center: Point, size: Size){

       let originX = center.x - (size.width / 2)

       let originY = center.y - (size.height / 2)

       self.init(origin: Point(x: originX, y: originY), size: size)

    }

}

let rect1 = Rect()

let rect2 = Rect(origin: Point(x: 2.0, y: 2.0), size: Size(width: 5.0, height: 5.0))

let rect3 = Rect(center: Point(x: 4.0, y: 4.0), size: Size(width: 3.0, height: 3.0))

 

//自动继承：满足以下规则时

//规则1：如果子类没有定义任何指定构造器，它将自动继承所有超类的指定构造器(Designated Method)

//规则2：如果子类提供了所有超类指定构造器的实现（不管是通过规则1继承过来的，还是通过自定义实现的），它将自动继承所有超类的便利构造器(Convenience Method)

//涉及覆盖初始化方法的，需要写override，顺序没要求，比如可以override convenience，也可以convenienceoverride

class Food {

   var name: String

   init(name: String) {

       self.name = name

    }

    convenience init() {

       self.init(name: "Unname")

    }

}

classRecipeIngredient: Food {

   var quantity: Int

   init(name: String, quantity: Int) {

       self.quantity = quantity

       super.init(name: name)

    }

    override convenience init(name: String) { //自定义便利初始化方法重写了父类的主初始化方法--符合规则2

       self.init(name: name, quantity: 1)

    }

//   convenience overrideinit() { //只有主初始化方法才需要重写，便利初始化方法不需要override，子类只要定义了相同类型的便利初始化方法就不会继承父类的...

//        self.init(name: "OverRideName")

//    }

}

let Recipe1 = RecipeIngredient()

 

class ShoppingListItem: RecipeIngredient {//满足规则1

   var purchased = false

   var description: String{

        var output = "\(quantity) x \(name.lowercaseString)"//这里self.quantity和super.同等效果

       output += purchased ? " Y": " N"

       return output

    }

}

var breakfastList = [

    ShoppingListItem(),

    ShoppingListItem(name: "Bacon"),

   ShoppingListItem(name: "Eggs", quantity: 6)

]

breakfastList[0].name = "COLA"

breakfastList[0].quantity = 3

breakfastList[0].purchased = true

breakfastList[0].description

for item in breakfastList {

   println(item.description)

}

 

//要求必须实现或重写的构造器

//在超类的构造器上写required,表示每个子类都必须实现这个构造器

//这种情况不需要写override

class SomeClass {

    required init() {

       //code

    }

}

class SomeSubclass: SomeClass {

    required init() {

       //code

    }

}

 

//通过闭包或函数来初始化

//闭包结尾要接一对小括号，表示需要Swift立刻执行此闭包，如果写漏，则相当于将闭包本身作为值赋给属性。

//在执行闭包时，实例的其他部分还未初始化，因此不能在闭包里面访问其他属性，包括有默认值的属性，也不能使用self

struct Checkerboard {

   let boardColors: [Bool] = {

       var temp :[Bool] = []

       var isBlack = false

       for i in 1...10 {

           for j in 1...10 {

               temp.append(isBlack)

               isBlack = !isBlack

           }

           isBlack = !isBlack

       }

       return temp

    }()

   func squareIsBlackAtRow(#row: Int, column:Int) -> Bool {

       return boardColors[(row * 10) + column]

    }

}

let board = Checkerboard()

println(board.squareIsBlackAtRow(row:0,column: 1))//true

println(board.squareIsBlackAtRow(row:1,column: 1))//false

 

//析构---只能用于类，每个类最多只能有一个析构函数

//析构函数不带参数，不用带括号

//格式为：deinit{}

//进行一些额外的清理处理,在实例释放前被自动调用

//子类析构函数实现后会自动调用超类的析构函数

class Person {

   var counts = 1

   let name: String

   init(name: String){

       self.name = name

        println(" \(name) is being initialized")

       counts = 4

    }

   deinit {

        println(" \(name)is being deinitialized")

       counts = 2

    }

}

weak var reference1 : Person? = Person(name: "John")

//reference1 = nil 正常来说，将变量赋值为nil即可(不需要使用weak)，但playground对实例有特殊处理(貌似进行了强引用，及时指针指向nil也没有释放实例，因此使用weakvar)