引入：不给存储属性赋值，报错
定义类属性不报错，结构体的实例时必须为所有的存储属性设置一个合适的初始值
不报错，3种方式：
1 可选型
2 直接定义的时候初始化，直接=
3 构造函数中初始化

知识点一：构造函数的作用
1、构造函数用于初始化一个类的实例（创建对象）
2、默认情况下载创建一个类时,必然会调用一个构造函数
3、即便是没有编写任何构造函数,编译器也会提供一个默认的构造函数

知识点二：默认构造函数
1、使用 init 关键字来写，
2、构造函数没有func修饰
3、构造函数默认完成调用 不能手动调用
4、构造函数就像一个没有形式参数的实例方法，

知识点三：自定义构造函数
1、可以自定义构造函数
2、自定义构造函数和默认构造函数可以同时存在

class Person{
    var name:String
    var age:Int
    var sex:String
    //默认构造函数
     init() {
         print("init被调用")
         self.name = "张三"
         self.age = 10
         self.sex = "男"
     }
     //自定义构造函数
     init(name:String,age:Int,sex:String){
         self.name = name
         self.age = age
         self.sex = sex
     }
}
var p = Person()
p.name
p.age

var p2 = Person(name: "lisi", age: 18, sex

指定与便利构造函数
指定构造函数和遍历构造函数(对号官网)
1、概念

1）指定：标配，至少一个，初始化所有属性
思考:怎么判断是不是指定函数？就看是不是初始化了所有存储属性。
2）便利：辅助，最终调用本类里的指定。
思考：如何区分指定和便利？

2、语法结构
便利构造函数需要在init前加上convinience关键字

3、必须遵守的规范(案例演示)

规则 1——指定构造函数必须从它的直系父类调用指定构造函数
规则 2——便捷构造函数必须从相同的类里调用另一个构造函数(可以是指定也可以是便捷)
规则 3——便捷构造函数最终必须调用一个指定构造函数
简单记忆的这些规则的方法如下：
指定构造函数必须总是向上委托。
便捷构造函数必须总是横向委托。

import Foundation
class Car{
    var speed:Double
    //var a:Int
    
    //指定构造函数(初始化所有属性)
    init(speed:Double){
        self.speed = speed
    }
    //便利构造函数，必须调用指定构造函数
    convenience init(){
        self.init(speed:80.0)
    }
}
class Bue:Car{
    var wheels:Int
    var banner:String
    
    //指定构造器：提问初始化几个属性，自己的属性自己初始化，父类的调用父类
    init(wheels:Int,banner:String,speed:Double){
        self.wheels=wheels
        self.banner=banner
        //self.speed=speed必须用父类指定的构造函数初始化
        super.init(speed:speed)
    }
    //便捷构造器-必须调用其他的构造函数（指定)
    convenience init(wheels:Int){
        self.init(wheels:wheels,banner:"",speed:0.0)
        print("test")
    }
    //便捷构造器-必须调用其他的构造函数（便捷）
    convenience init(){
        self.init(wheels:8)
    }
}

构造函数的继承
猜一猜，可不可以继承父类的构造方法？
子类在默认情况下不继承父类的构造器。
子类继承父类的构造函数是有条件的，遵守以下2个规则：

规则1——如果子类没有定义任何指定构造函数，它会自动继承父类所有指定构造函数
规则2——如果子类提供了所有父类指定构造函数的实现(通过规则1继承来的或者提供自定义实现的)，那么它会自动继承所有父类便捷初始化器

import Foundation
//提问：此时几个指定构造，几个便捷
class Car{
    var speed:Double
    var banner:String
    //指定构造函数(初始化所有属性)
    init(speed:Double,banner:String){
        self.speed = speed
        self.banner = banner
    }
    //指定构造函数
    init(speed:Double){
        self.speed = speed
        self.banner = "10000A"
    }
    //便捷构造函数，必须调用指定构造函数
    convenience init(){
        self.init(speed:20.0,banner:"20002")
        print("父类便利构造")
    }
}
//[案例一]如果子类没有定义任何指定构造函数，它会自动继承父类所有指定构造函数
class Bus:Car{
    
}
var b1 = Bus(speed:30.0)
var b2 = Bus()
b2.banner
var b3 = Bus(speed:40.1,banner:"b3000")
//[案例二]如果重写了父类的所有指定，继承便捷
//[提问]如果重写了父类的部分指定，还能继承便捷吗？不能
class Ka:Car{
    var weight:Double
    //重写父类指定
    override init(speed:Double){
        self.weight = 100.0
        super.init(speed:speed,banner:"Ka0001")
    }
    //重写父类指定
    override init(speed:Double,banner:String){
        self.weight = 100.0
        super.init(speed:speed,banner:banner)
    }
    //便捷构造器不算重写,不用加override
    convenience init(){
        self.init(speed:20.0,banner:"20002")
        print("父类便利构造")
    }
    
}
var Ka1 = Ka()
Ka1.speed

//[案例三]重写父类的便捷呢？便捷不存在重写概念

可失败的构造函数
产生原因
1、定义类、结构体或枚举初始化时可以失败
2、失败原因，包括给初始化传入无效的形式参数值，或缺少某种外部所需的资源，又或是其他阻止初始化的情况
3、为了处理这种可能，在类、结构体或枚举中定义一个或多个可失败的构造函数。

定义可失败的构造函数
通过在 init 关键字后面添加问号init?
可失败的构造函数里面应该有一个 return nil 的语句(没有也不报错)
通过可失败的构造函数构造出来的实例是一个可选型,所以配合解包

import Foundation
//【案例】普通的构造函数
class Animal{
    var species:String
    init(species:String) {
        self.species = species
    }
}
//提问:cat1这个变量是什么类型？
var cat1 = Animal(species: "Cat")
print(cat1.species)

//【案例二】 可失败
class Animal2{
    var species:String
    init?(species:String) {
        if species.isEmpty{//此时加条件，如果传进来是空值，就构造失败。
            return nil //一旦return nil，可选型，要加？
        }
        self.species = species
    }
}
//提问:cat2这个变量是什么类型？
//构造成功的情况
var cat2 = Animal2(species: "cat")
//print(cat2.species)
if let cat2 = cat2{
    print(cat2.species)
}
//构造失败的情况
var dog = Animal2(species: "")
print(dog)