swift基础语法(27- 构造方法,带参数的构造方法,常量存储属性与构造方法,结构体构造方法)

构造方法

作用: 对实例对象的内容进行初始化
Swift要求类或者结构体中的存储属性(非lazy的)在对象构造完毕后要有初始化值
语法:
init(参数列表){ 初始化代码 }

注意:

1.在Swift中类/结构体/枚举都需要构造方法

2.构造方法的作用仅仅是用于初始化属性, 而不是分配内容, 分配内存是系统帮我们做的
3.构造方法是隐式调用的, 通过 类名称() 形式创建一个对象就会隐式调用init()构造方法
4.如果所有的存储属性都有默认值, 可以不提供构造方法, 系统会提供一个隐式的构造方法

5.如果存储属性可以提供缺省, 那么提倡大家使用设置缺省值的方式,

    这样可以简化代码(不用自定义构造方法, 不用写存储属性类型)

 

class Person {

    var name:String = "qbs"

    var age:Int
    func description() ->String{
        return "name = (name) age = (age)"
    }
    init()
    {
        print("init")
        age = 30
    }
}

 1.分配内存

 2.初始化name和age

 3.构造方法是隐式调用的

var p = Person()

p.description() 显示调用

输出结果: init

 

带参数的构造方法

class Person {
    var name:String
    var age:Int
    func description() ->String{
        return "name = (name) age = (age)"
    }

    构造方法的内部参数, 默认也是外部参数

    而函数的内部参数默认不会当做外部参数

    而方法的内部参数, 从第二个开始才会当做外部参数

    init(name:String, age:Int)

    构造方法对属性的顺序没有要求,

       只要保证对象构造完时所有存储属性被初始化即可

    init(age:Int, name:String)
    {
        self.name = name
        self.age = age
    }
    func setName(name:String, age:Int)
    {
       
    }
}

var p = Person(age: 30, name: "qbs")

p.setName("qbs", age: 30)

func setName(name:String, age:Int)
{
   
}

p.setName("qbs", age: 30)

 

 

常量存储属性与构造方法

常量存储属性只能通过缺省值或在构造方法中被修改

其它任何地方都不能修改

class Person {

    var name:String = "qbs"

    let age:Int
    init(age:Int, name:String)
    {
        self.age = age
        self.name = name
    }
    func description() ->String{
        return "name = (name) age = (age)"
    }

}

var p = Person(age: 30, name:"zs")

print(p3.description())

输出结果: name = zs age = 30

常量存储属性初始化之后不允许被修改

p.age = 10

 

可选属性与构造方法

class Car {
    let name:String
    init(name:String)
    {
        self.name = name
    }
}

class Person {
    let name:String
    var age:Int

    var car:Car?

    可选值存储属性可以不再构造方法中初始化,

    也就是说可选值在对象构造完毕后不用初始化

    其实如果不对可选存储属性进行初始化, 默认就是nil

    init(age:Int, name:String)
    {
        self.age = age
        self.name = name
    }
    func description() ->String{
        return "name = (name) age = (age) car = (car)"
    }
}

var p = Person(age: 10, name: "qbs")

print(p.description())

输出结果: name = qbs age = 10 car = nil

 

结构体构造方法

struct Rect{

    此时即没有提供缺省值, 也没有提供构造方法, 但是编译通过

    因为默认情况下, 结构体会给结构体提供一个默认的成员逐一构造器

    var Double = 0.0

    var height:Double = 0.0

    

    系统默认会提供一个类似的方法

    init(Double, height:Double)
    {
    self.width = width
    self.height = height
    }

   

    

    init()
    {
    self.width = 0.0
    self.height = 0.0

    }

}

 注意:

 1.在类中默认是没有逐一构造器的

 2.如果在结构体中自定义了构造方法, 那么系统不会生成默认的逐一构造器

 3.如果给存储属性提供了缺省值, 系统还是会提供默认的逐一构造器

 4.如果给存储属性提供了缺省值, 可以使用不带参数的方法初始化结构体

var r = Rect()

print("width=(r.width),height=(r.height)")

输出结果: width=0.0,height=0.0

var r = Rect( 10, height: 20)

print("width=(r.width),height=(r.height)")

输出结果: width=10.0,height=20.0

 

"值类型"的构造器代理
构造器代理: 构造方法之间的相互调用
构造方法可以调用其他构造方法来完成实例的构造, 称之为构造器代理

好处: 减少构造方法之间的重复代码

struct Rect {
    var Double
    var height:Double
    init(Double, height:Double)
    {
        self.width = width
        self.height = height
    }
   
    init()

    {

        self.width = 0

        self.height = 0

        构造器代理

        self.init(0, height:0)
    }
   
    func show(){
        print("width = (width) height = (height)")
    }
}
var r = Rect()

r.show()

输出结果: width = 0.0 height = 0.0

 

var r1 = Rect( 100, height: 100)

r1.show()

输出结果:

width = 100.0 height = 100.0

 

 

通过闭包或者全局函数/类方法 设置存储属性的缺省值

如果需要经过计算, 或者需要进行一些额外的操作才能确定初始值时

就可以通过闭包或全局函数设置存储属性的缺省值

 

func getValue() ->Int
{
    print("getValue")
    return 55
}

class Person {

    var name: String

    系统在初始化的时候会隐式执行闭包,

         将闭包的执行结果赋值给存储属性

    注意: 闭包后面一定要有(), 代表执行闭包

    var age: Int = {

        () -> Int in 返回值可以省略,

                  默认返回值的类型就是存储属性的类型

        print("age 闭包")
        return 30
    }()
    lazy var height:Double = {
        print("lazy 闭包")
        return 175.0
    }()
   
    var age2:Int = getValue()
    var age3:Int = Person.getValue2()

   

     不能这样写, 因为调用方法时对象还没有初始化完毕

     self只有当所有的存储属性都初始化完毕之后才可以用

     var age3:Int = self.getValue3()

    init(name:String)
    {
        print("init")
        self.name = name
    }
    class func getValue2() -> Int{
        print("class getValue2")
        return 100
    }
    func getValue3() -> Int
    {
        return 88
    }
}

var p = Person(name: "qbs")

懒加载是用到时才执行, 而闭包赋值是初始化时就会执行

print(p.height)

 

输出结果:

age 闭包
getValue
class getValue2
init
lazy 闭包

175.0