分析要点：
1、初始化：类型（枚举，结构，类）的实例在构建过程中得一系列过程
2、初始化的主要目的：对内部的存储属性赋值
3、结构：如果不自觉添加初始化，会自动添加默认init和memberwise init
类的初始化：代码如下
class YY
{
var i:int// 会报错，因为没有初始值（存储属性）
}
//NN没有构造器
class NN{
var i:int
init(a:int){i=1}
}
//黄金规则1：实例化之后所有的存储属性必须有值（两种赋值方法）
//专门（特定）的初始化器designated initiliazer
//作用：给本类的所有存储属性赋值
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