初始化2

/*
初始化：类型（枚举，结构，类）的实例在构建过程中得一系列过程

初始化的主要目的：对内部的存储属性赋值

结构：如果不自己添加初始化，会自动添加默认init和memberwise init

*/
//***********类的初始化*****************/
 

class XX {

}

//会报错，因为没有初始值（存储属性）

//class YY {
// var i:Int
//}

//下面有默认init，因为i有初始值

class MM {
var i: Int = 1
}

//NN没有构造器

class NN {
var i: Int
init(a: Int){
i = a
}
}

//黄金规则1：实例化之后所有的存储属性必须有值（两种方法赋值）

//专门（特定）的初始化器designated initiliazer

//作用：1.给本类的所有存储属性赋值

class AA {
var m:Int
var n:Int
init(mm: Int,nn: Int) {
m = mm
n = nn
}
init() {
m = 111
n = 22

//这里会报错，表明特定的init之间不能相互调用
//所以建议：实际每个类只写一个特定的初始化器

// self.init(mm:111,nn:222)
}

//便利的初始化器需要调用专门的初始化器(直接或间接都可以）

convenience init(mm: Int){

self.init(mm:mm,nn:1)
}

convenience init(nn: Int){
//self.init(mm:1,nn:2)
self.init(mm:nn)
}

}

**************有了继承****

class Parent {
var i:Int = 1
// var m: String? //只有可为nil的类型会有默认值

var m: Int
init(m: Int) {
self.m = m
}
}

class Child :Parent {
var n: Int
init(n: Int) {
//阶段一
self.n = n //先把自己的活干完
super.init(m: 1)//在叫父类干
//阶段二
m = 2//不满意父类的，就自己干

}

}

/**
专门初始化器：
1.可以有多个
2.互相不能调用，每一个负责实现所有本类存储属性的初始化
3.负责处理继承过来的存储属性的初始化。
3.1 相信别人，所以表现就是调用父类的特定初始化器（不能
调用父类的便利初始化器）
便利的初始化器：
1.可以有多个
2.可以调用本来其它的便利初始化器，也可以调用本类的特定初始化器
3.最终一定是调用本类的特定初始化器
*/

//*******初始化器的继承***********

class P{
var m: Int
init(m: Int) {
self.m = m
}
init(m: Int,f: Bool) {
self.m = m
}
convenience init() {
self.init(m: 1)
}

}
class C: P{
var n: Int = 1
override init(m: Int) {
super.init(m: m)
}
override init(m: Int, f: Bool) {
super.init(m: m, f: f)
}

// init(n: Int) {
// self.n = n
// super.init(m: 1)
// }
}

/*默认情况下，子类不会继承父类的构造器
如果想让子类继承父类的构造器，有以下几个条件
1.自己的属性必须已经赋值（声明时）
2.会继承父类的特定初始化器
3.如果子类把父类所有的特定初始化器都实现了，
那么子类也会继承父类的所有便利初始化器

*/

//let ins = C(

//***********可失败的

class FailureClass {
var name:String
init?(name:String) {

self.name = name
if name.isEmpty { return nil}


}
}

//返回的是一个可为nil的类型

let ins = FailureClass(name: "dasf")
ins?.name
if let xx = ins {
xx.name
}
ins!.name