构造方法

 

 

/*

/*

/*

/*

 构造方法:

 构造方法:

 结构体:

 结构体:

 

 

 结构体是用来封装差异或同等档次的数码的, 斯维夫特中的结构体是壹类项目,
能够定义属性和办法(甚至构造方法和析构方法等)

 结构体是用以封装分歧或平等档次的数目的, Swift中的结构体是1类项目,
能够定义属性和办法(甚至构造方法和析构方法等)

 成效: 对实例对象的剧情张开开端化

 成效: 对实例对象的剧情开始展览初步化

 格式:

 格式:

 斯维夫特供给类或然结构体中的存款和储蓄属性(非lazy在)在目标组织实现后要有开首化值

 斯威夫特须要类大概结构体中的存储属性(非lazy在)在目标组织落成后要有早先化值

 struct 结构体名称 {

 struct 结构体名称 {

 

 

 结构体属性和措施

 结构体属性和艺术

 语法:

 语法:

 }

 }

澳门葡京备用网址, init(参数列表){ 开首化代码 }

 init(参数列表){ 伊始化代码 }

 */

 */

 

 

 

 

 注意: 一.在斯威夫特中类/结果提/枚举都亟待构造方法;

 注意: 1.在斯维夫特中类/结果提/枚举都急需构造方法;

struct Rect {

struct Rect {

 二.构造方法的效用只是是措辞初步化属性, 而不是分配内容,
分配内部存款和储蓄器是系统帮咱们做的;

 二.构造方式的功力只是是措辞初阶化属性, 而不是分配内容,
分配内部存款和储蓄器是系统帮大家做的;

    var width: Double = 0.0

    var width: Double = 0.0

 三.构造方法是隐式调用的, 通过 类名称() 产生成立三个目的就会隐式调用
init() 构造方法;

 三.构造方法是隐式调用的, 通过 类名称() 变成成立二个对象就会隐式调用
init() 构造方法;

    var height:Double = 0.0

    var height:Double = 0.0

 4.万1具备的积存属性都有默许值, 可以不提供构造方法,
系统会提供三个隐式的构造方法;

 四.借使具备的蕴藏属性都有暗许值, 能够不提供构造方法,
系统会提供一个隐式的构造方法;

}

}

 5.要是存款和储蓄属性可以提供缺省, 那么提倡大家使用安装缺省值的主意,
那样能够简化代码(不用自定义构造方法, 不用写存款和储蓄属性类型)

 5.假如存款和储蓄属性可以提供缺省, 那么提倡大家利用安装缺省值的方法,
那样能够简化代码(不用自定义构造方法, 不用写存储属性类型)

// 假若结构体的属性有默许值, 能够一贯利用()构造一个结构体

// 假若结构体的本性有私下认可值, 能够直接动用()构造三个结构体

 */

 */

// 假使结构体的性质没有暗中认可值, 必须利用种种协会器实例化结构体

// 假若结构体的品质未有私下认可值, 必须选用各种组织器实例化结构体

 

 

 

 

class Person {

class Person {

var r = Rect()

var r = Rect()

    var name: String = “hjq”

    var name: String = “hjq”

print(“width = \(r.width), height = \(r.height)”)

print(“width = \(r.width), height = \(r.height)”)

//    var age: Int = 20

//    var age: Int = 20

 

 

    var age:Int

    var age:Int

// 结构体属性访问 使用语法

// 结构体属性访问 使用语法

    func description() -> String {

    func description() -> String {

r.width = 99.9

r.width = 99.9

        return “name = \(name) age = \(age)”

        return “name = \(name) age = \(age)”

r.height = 120.5

r.height = 120.5

    }

    }

print(“width = \(r.width), height = \(r.height)”)

print(“width = \(r.width), height = \(r.height)”)

    init() {

    init() {

 

 

        print(“init”)

        print(“init”)

/*

/*

        age = 30

        age = 30

 结构体构造器

 结构体构造器

    }

    }

 斯威夫特中的结构体和类跟其余面向对象语言一样都有构造函数, 而OC是不曾的

 Swift中的结构体和类跟别的面向对象语言同样都有构造函数, 而OC是平素不的

}

}

 Swift供给实例化三个结构体或类的时候,全体的分子变量都不能够不有初阶值,
构造函数的含义就是用来起始化全部成员变量的, 而不是分配内存,
分配内存是系统帮大家做的.

 斯维夫特要求实例化1个结构体或类的时候,全数的成员变量都不可能不有先导值,
构造函数的意思正是用来早先化全数成员变量的, 而不是分配内部存款和储蓄器,
分配内部存款和储蓄器是系统帮大家做的.

// 一.分配内部存款和储蓄器; 贰.开头化name和age; 三.构造方法是隐式调用的

// 壹.分配内部存款和储蓄器; 2.初阶化name和age; 三.构造方法是隐式调用的

 假诺结构体中的全数属性都有暗中认可值, 可以调用()构造多少个结构体实例

 要是结构体中的全部属性都有私下认可值, 可以调用()构造多少个结构体实例

var p = Person()

var p = Person()

 假设结构体中的属性没有暗中同意值, 能够自定义构造器,
并在构造器中给具备的属性赋值

 假诺结构体中的属性未有暗中认可值, 能够自定义构造器,
并在构造器中给全体的天性赋值

var descripString: String = p.description() //展现调用

var descripString: String = p.description() //突显调用

 其实结构体有3个默许的逐壹构造器, 用于在开头化时给具备属性赋值

 其实结构体有七个暗中同意的逐条构造器, 用于在开始化时给全数属性赋值

print(p.age)

print(p.age)

 */

 */

 

 

 

 

print(“================================”)

print(“================================”)

struct Rect2 {

struct Rect2 {

 

 

    var width:Double

    var width:Double

 

 

    var height:Double = 0.0

    var height:Double = 0.0

/** 带有参数的构造方法 **/

/** 带有参数的构造方法 **/

}

}

class Person2 {

class Person2 {

// 逐壹构造器

// 逐1构造器

    var name:String

    var name:String

var r1 = Rect2(width: 10.0, height: 10.0)

var r1 = Rect2(width: 10.0, height: 10.0)

    var age:Int

    var age:Int

// 错误写法一: 顺序必须和结构体中成员的顺序壹致

// 错误写法一: 顺序必须和结构体中成员的各类1致

    func description() -> String {

    func description() -> String {

//var r1 = Rect2(height: 10.0, width: 10.0) // Error!

//var r1 = Rect2(height: 10.0, width: 10.0) // Error!

        return “name = \(name) age = \(age)”

        return “name = \(name) age = \(age)”

// 错误写法2: 必须包涵全数成员

// 错误写法2: 必须包蕴全数成员

    }

    }

//var r1 = Rect2(width: 10.0)  //Error!

//var r1 = Rect2(width: 10.0)  //Error!

    //壹.构造方法的里边参数, 暗中同意也是表面参数;

    //1.构造方法的中间参数, 暗许也是表面参数;

 

 

    //二.而函数的在那之中参数暗中同意不会作为外部参数;

    //贰.而函数的内部参数暗中认可不会作为外部参数;

/*

/*

    //三.而艺术的内部参数, 从第2个起初才会作为外部参数;

    //3.而艺术的里边参数, 从第三个起来才会作为外部参数;

 结构体中定义成员方法

 结构体中定义成员方法

    //4.构造方法对质量的各类未有须求,
只要保障对象组织完时全数存款和储蓄属性被初叶化就能够.

    //四.构造方法对品质的相继未有必要,
只要保险对象协会完时全部存储属性被开始化就能够.

构造方法。 在C和OC中结构体只有总体性, 而斯维夫特中结构体中还是能够定义方法

 在C和OC中结构体唯有总体性, 而Swift中结构体中还足以定义方法

    init(age:Int, name:String)

    init(age:Int, name:String)

 */

 */

    {

    {

 

 

        self.name = name

        self.name = name

struct Rect3 {

struct Rect3 {

        self.age = age

        self.age = age

    var width:Double

    var width:Double

    }

    }

    var height:Double = 0.0

    var height:Double = 0.0

    func setName(name:String, age:Int)

    func setName(name:String, age:Int)

    // 壹.给组织体定义3个方法, 该措施属于该结构体

    // 一.给组织体定义3个措施, 该措施属于该结构体

    {

    {

    // 贰.结构体中的成员方法必须选拔有些实例调用

    // 二.结构体中的成员方法必须使用某些实例调用

        self.name = name

        self.name = name

    // 三.成员方法能够访问成员属性

    // 三.成员方法能够访问成员属性

        self.age = age

        self.age = age

    func getWidth() -> Double {

    func getWidth() -> Double {

    }

    }

        return width

        return width

}

}

    }

    }

var p2 = Person2(age: 25, name: “hjq”)

var p2 = Person2(age: 25, name: “hjq”)

}

}

p2.setName(name: “hjq”, age: 30)

p2.setName(name: “hjq”, age: 30)

 

 

print(p2.description())

print(p2.description())

var r2 = Rect3(width: 10.0, height: 10.0)

var r2 = Rect3(width: 10.0, height: 10.0)

 

 

//结构体中的成员方法是和有个别实例对象绑定在一同的, so, 什么人调用,
方法中走访的性质正是何人

//结构体中的成员方法是和某些实例对象绑定在共同的, so, 什么人调用,
方法中访问的习性正是何人

p2.setName(name: “hjq”, age: 23)

p2.setName(name: “hjq”, age: 23)

// 赚取r2那些目的的肥瘦

// 获得r二那几个目的的增长幅度

print(p2.description())

print(p2.description())

print(r2.getWidth())

print(r2.getWidth())

 

 

 

 

print(“================================”)

print(“================================”)

var r3 = Rect3(width: 50.0, height: 30.0)

var r3 = Rect3(width: 50.0, height: 30.0)

 

 

// 获得r三这么些目标的上升的幅度

// 获得r三那一个目的的宽度

/*

/*

print(r3.getWidth())

print(r3.getWidth())

 常量存储属性与构造方法

 常量存款和储蓄属性与构造方法

 

 

 常量存款和储蓄属性只好通过缺省值或在构造方法中被更换, 别的任哪个地点方都无法改改

 常量存储属性只好通过缺省值或在构造方法中被涂改, 别的任哪里方都不可能改改

 

 

 */

 */

/** 结构体是值类型 **/

/** 结构体是值类型 **/

class Person3 {

class Person3 {

 

 

    var name:String = “hjq”

    var name:String = “hjq”

struct Rect4 {

struct Rect4 {

    var age:Int

    var age:Int

    var width:Double

    var width:Double

    init(age:Int, name:String)

    init(age:Int, name:String)

    var height:Double = 0.0

    var height:Double = 0.0

    {

    {

    func show() -> Void {

    func show() -> Void {

        self.name = name

        self.name = name

        print(“width = \(width) height = \(height)”)

        print(“width = \(width) height = \(height)”)

        self.age = age

        self.age = age

    }

    }

    }

    }

}

}

    func description() -> String {

    func description() -> String {

 

 

        return “name = \(name) age = \(age)”

        return “name = \(name) age = \(age)”

var r4 = Rect4(width: 10.0, height: 10.0)

var r4 = Rect4(width: 10.0, height: 10.0)

    }

    }

var r5 = r4

var r5 = r4

}

}

print(r4)

print(r4)

var p3 = Person3(age: 30, name: “jq”)

var p3 = Person3(age: 30, name: “jq”)

print(r5)

print(r5)

print(p3.description())

print(p3.description())

 

 

//p3.name = “hello” //常量存款和储蓄属性早先化之后不允许被退换!
虽没报错,不过不容许,这点在后面开辟中开掘验证!

//p3.name = “hello” //常量存款和储蓄属性起始化之后不容许被涂改!
虽没报错,但是不容许,那点在背后开拓中挖掘验证!

/*

/*

 

 

 赋值有二种景况

 赋值有二种情状

 

 

 一.指向同壹块存款和储蓄空间

 壹.指向同1块存款和储蓄空间

print(“================================”)

print(“================================”)

 贰.四个区别实例, 但内容千篇一律

 二.七个区别实例, 但内容同样

 

 

 */

 */

/** 可选属性与构造方法 **/

/** 可选属性与构造方法 **/

r4.show()

r4.show()

 

 

r5.show()

r5.show()

class Car {

class Car {

r4.width = 20.0

r4.width = 20.0

    let name:String

    let name:String

 

 

    init(name:String)

    init(name:String)

// 结构体是值类型, 结构体之间的赋值其实是将r肆中的值完全拷贝一份到r第55中学,
所以他们多个是例外的实例

// 结构体是值类型, 结构体之间的赋值其实是将r四中的值完全拷贝1份到r5中,
所以他们五个是见仁见智的实例

    {

    {

r4.show()

r4.show()

        self.name = name

        self.name = name

r5.show()

r5.show()

    }

    }

 

 

}

}

class Person4 {

class Person4 {

    let name:String

    let name:String

    var age:Int

    var age:Int

    var car:Car?

    var car:Car?

    

    

    //一.可选值存款和储蓄属性能够不再构造方法中初始化;

    //1.可选值存款和储蓄属性可以不再构造方法中先河化;

    //二.也正是说可选值在目标组织完结后不要开始化;

    //贰.也正是说可选值在对象组织完结后不要开头化;

    //三.其实如若不对可选存款和储蓄属性进行开端化, 暗中认可正是nil

    //三.其实要是不对可选存款和储蓄属性举办起先化, 默许正是nil

    init(age:Int, name:String)

    init(age:Int, name:String)

    {

    {

        self.age = age

        self.age = age

        self.name = name

        self.name = name

    }

    }

    func description() -> String {

    func description() -> String {

        return “name = \(name) age = \(age)”

        return “name = \(name) age = \(age)”

    }

    }

}

}

 

 

 

 

/** 结构体与构造方法 **/

/** 结构体与构造方法 **/

struct Rect {

struct Rect {

    //此时既未有提供缺省值, 也尚无提供构造方法, 然则编写翻译通过

    //此时既未有提供缺省值, 也绝非提供构造方法, 不过编写翻译通过

    //因为暗中同意景况下, 结构体会给结构体提供贰个暗许的分子相继构造器

    //因为暗中认可意况下, 结构体会给结构体提供一个暗中认可的积极分子相继构造器

    var width:Double = 0.0

    var width:Double = 0.0

    var height:Double = 0.0

    var height:Double = 0.0

    /*

    /*

    // 系统默许会提供一个类似的章程

    // 系统暗中认可会提供三个看似的艺术

    init(width:Double, height:Double)

    init(width:Double, height:Double)

    {

    {

        self.width = width

        self.width = width

        self.height = height

        self.height = height

    }

    }

    */

    */

    /*

    /*

    init() {

    init() {

        self.width = 0.0

        self.width = 0.0

        self.height = 0.0

        self.height = 0.0

    }

    }

    */

    */

}

}

// 注意: 一.在类中私下认可是从未各种构造器的

// 注意: 一.在类中默许是向来不各样构造器的

// 贰.假如在结构体中自定义了构造方法, 那么系统不会变动默许的顺序构造器

// 贰.比方在结构体中自定义了构造方法, 那么系统不会生成私下认可的各类构造器

// 三.若是给存款和储蓄属性提供了缺省值, 系统或许会提供私下认可的顺序构造器

// 三.比方给存款和储蓄属性提供了缺省值, 系统或许会提供暗中同意的各种构造器

//var r = Rect(width: 1.0, heigth: 1.0)

//var r = Rect(width: 1.0, heigth: 1.0)

// 四.假使给存款和储蓄属性提供了缺省值, 能够应用不带参数的法子伊始化结构体

// 四.比方给存款和储蓄属性提供了缺省值, 可以行使不带参数的秘技初阶化结构体

var r = Rect()

var r = Rect()

 

 

 

 

/*

/*

 “值类型”的构造器代理

 “值类型”的构造器代理

 构造器代理: 构造方法之间的并行调用

 构造器代理: 构造方法之间的交互调用

 构造方法能够调用其余构造方法来落成实例的组织, 称之为构造器代理

 构造方法能够调用别的构造方法来成功实例的构造, 称之为构造器代理

 好处: 收缩构造方法之间的双重代码

 好处: 减弱构造方法之间的再一次代码

 */

 */

 

 

struct Rect2 {

struct Rect2 {

    var width:Double, height:Double

    var width:Double, height:Double

    init(width:Double, height:Double)

    init(width:Double, height:Double)

    {

    {

        self.width = width

        self.width = width

        self.height = height

        self.height = height

    }

    }

    init()

    init()

    {

    {

//        self.width = 0.0

//        self.width = 0.0

//        self.height = 0.0

//        self.height = 0.0

        //构造器代理

        //构造器代理

        self.init(width: 0, height: 0)

        self.init(width: 0, height: 0)

    }

    }

    func show()

    func show()

    {

    {

        print(“width = \(width) height = \(height)”)

        print(“width = \(width) height = \(height)”)

    }

    }

}

}

var r2 = Rect2()

var r2 = Rect2()

r2.show()

r2.show()

var r3 = Rect2(width: 100, height: 100)

var r3 = Rect2(width: 100, height: 100)

r3.show()

r3.show()

 

 

 

 

print(“================================”)

print(“================================”)

 

 

 

 

/*

/*

 通过闭包或然全局函数/类措施 设置存款和储蓄属性的缺省值

 通过闭包或许全局函数/类格局 设置存款和储蓄属性的缺省值

 假设急需经过计量,
也许要求张开一些11分的操作技能明确开首值时就足以经过闭包或全局函数设置存款和储蓄属性的缺省值

 固然急需经过测算,
或然必要张开一些卓殊的操作才能鲜明开端值时就足以由此闭包或全局函数设置存款和储蓄属性的缺省值

 */

 */

 

 

func getValue() ->Int

func getValue() ->Int

{

{

    print(“getValue”)

    print(“getValue”)

    return 55

    return 55

}

}

class Person5 {

class Person5 {

    var name:String

    var name:String

    

    

    //系统在起始化的时候会隐式实行闭包, 将闭包的实施结果赋值给存款和储蓄属性

    //系统在开端化的时候会隐式推行闭包, 将闭包的进行结果赋值给存款和储蓄属性

    //注意: 闭包后边必然要有(), 代表实行闭包

    //注意: 闭包前面料定要有(), 代表实践闭包

    var age:Int = {

    var age:Int = {

        () -> Int in  // 那壹行能够省略,
再次来到值是能够省略的,私下认可重回值的档次正是储存属性的档次

        () -> Int in  // 那1行能够省略,
再次来到值是足以回顾的,暗中同意重回值的门类便是储存属性的项目

       print(“age 闭包”)

       print(“age 闭包”)

        return 30

        return 30

    }()

    }()

    

    

    lazy var height:Double = {

    lazy var height:Double = {

      print(“lzay 闭包”)

      print(“lzay 闭包”)

        return 180.0

        return 180.0

    }()

    }()

    

    

    var age2:Int = getValue()

    var age2:Int = getValue()

    var age3:Int = Person5.getValue2()

    var age3:Int = Person5.getValue2()

    

    

    //壹.不能这么写, 因为调用方法时对象还尚未开端化落成;

    //一.无法如此写, 因为调用方法时对象还未有开头化落成;

    //二.self唯有当全数的储存属性都起始化完结之后才方可用.

    //二.self唯有当全部的囤积属性都开端化完成之后才方可用.

//    var age3:Int = Person5.getValue3()

//    var age3:Int = Person5.getValue3()

    

    

    init(name:String) {

    init(name:String) {

        self.name = name

        self.name = name

    }

    }

    class func getValue2() ->Int {

    class func getValue2() ->Int {

        print(“class getValue2”)

        print(“class getValue2”)

        return 100

        return 100

    }

    }

    func getValue3() -> Int {

    func getValue3() -> Int {

        return 99

        return 99

    }

    }

}

}

var p5 = Person5(name: “hjq”)

var p5 = Person5(name: “hjq”)

//懒加载是用到才实践, 而闭包赋值是初阶化时就会实施

//懒加载是用到才实行, 而闭包赋值是初叶化时就会实施

print(p5.height)

print(p5.height)

 

 

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*
*
Website