分析要点:
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