构造方法

By admin in 4858.com on 2019年4月22日

 

 

/*

/*

/*

/*

 构造方法:

 构造方法:

 结构体:

 结构体:

 

 

 结构体是用于封装分歧或一致类别的多寡的, 斯威夫特中的结构体是一类品种,
能够定义属性和格局(乃至构造方法和析构方法等)

 结构体是用来封装不一样或平等档案的次序的多寡的, 斯维夫特中的结构体是一类项目,
能够定义属性和方法(以至构造方法和析构方法等)

 效用: 对实例对象的始末展开初阶化

 功用: 对实例对象的始末展开开头化

 格式:

 格式:

 斯威夫特要求类只怕结构体中的存款和储蓄属性(非lazy在)在目标协会完成后要有开始化值

 Swift供给类也许结构体中的存款和储蓄属性(非lazy在)在对象组织完结后要有开始化值

 struct 结构体名称 {

 struct 结构体名称 {

 

 

 结构体属性和格局

 结构体属性和方法

 语法:

 语法:

 }

 }

 init(参数列表){ 初步化代码 }

 init(参数列表){ 先河化代码 }

 */

 */

 

 

 

 

 注意: 一.在斯维夫特中类/结果提/枚举都必要构造方法;

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

struct Rect {

struct Rect {

 二.构造主意的魔法只是是措辞初步化属性, 而不是分配内容,
分配内部存款和储蓄器是系统帮大家做的;

 二.构造办法的职能只是是措辞初步化属性, 而不是分配内容,
分配内存是系统帮大家做的;

    var width: Double = 0.0

    var width: Double = 0.0

 3.构造方法是隐式调用的, 通过 类名称() 产生创造二个对象就会隐式调用
init() 构造方法;

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

    var height:Double = 0.0

    var height:Double = 0.0

 4.比方具备的积累属性都有暗许值, 能够不提供构造方法,
系统会提供1个隐式的构造方法;

 肆.假如具备的积攒属性都有私下认可值, 能够不提供构造方法,
系统会提供2个隐式的构造方法;

}

}

 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需求实例化3个结构体或类的时候,全数的分子变量都不可能不有早先值,
构造函数的含义就是用来初阶化全部成员变量的, 而不是分配内部存款和储蓄器,
分配内部存款和储蓄器是系统帮我们做的.

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

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

 假使结构体中的全体属性都有私下认可值, 可以调用()构造三个结构体实例

 即使结构体中的全部属性都有默许值, 能够调用()构造2个结构体实例

var p = Person()

var p = Person()

 借使结构体中的属性未有默许值, 能够自定义构造器,
并在构造器中给具备的性能赋值

 假设结构体中的属性未有默许值, 能够自定义构造器,
并在构造器中给全部的质量赋值

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

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

 其实结构体有2个暗中认可的各样构造器, 用于在先河化时给持有属性赋值

 其实结构体有三个暗许的顺序构造器, 用于在初始化时给全体属性赋值

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)”

// 错误写法二: 必须带有全体成员

// 错误写法二: 必须带有全体成员

    }

    }

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

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

    //一.构造方法的里边参数, 暗中认可也是外表参数;

    //1.构造方法的中间参数, 暗中认可也是外表参数;

 

 

    //二.而函数的中间参数暗许不会作为外部参数;

    //2.而函数的当中参数默许不会作为外部参数;

/*

/*

    //三.而艺术的当中参数, 从首个起初才会作为外部参数;

    //三.而艺术的当中参数, 从第四个起来才会作为外部参数;

 结构体中定义成员方法

 结构体中定义成员方法

    //四.构造方法对质量的11未有必要,
只要保障对象社团完时全体存款和储蓄属性被起首化就能够.

    //四.构造方法对质量的顺序未有要求,
只要保证对象组织完时全体存款和储蓄属性被初步化即可.

 在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)

    // 1.给组织体定义八个主意, 该措施属于该结构体

    // 一.给组织体定义叁个方式, 该办法属于该结构体

    {

    {

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

    // 二.结构体中的成员方法必须使用有个别实例调用

        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)

// 获得r贰这几个目的的大幅

// 取得r2那几个目的的上升的幅度

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)

 

 

// 取得r3那些目标的小幅

// 取得r3这一个目标的宽窄

/*

/*

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())

 

 

//p三.name = “hello” //常量存储属性初步化之后不容许被改变!
虽没报错,可是不容许,这点在前边开垦中开掘验证!

//p三.name = “hello” //常量存款和储蓄属性早先化之后不相同意被修改!
虽没报错,不过不相同意,那一点在后头开采中发掘验证!

/*

/*

 

 

 赋值有二种情景

 赋值有二种情况

 

 

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

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

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

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

 二.五个例外实例, 但内容千篇1律

 二.八个例外实例, 但内容1律

 

 

 */

 */

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

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

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四中的值完全拷贝壹份到r5中,
所以他们多个是例外的实例

// 结构体是值类型, 结构体之间的赋值其实是将r4中的值完全拷贝一份到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?

    

    

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

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

    //贰.也正是说可选值在目的组织完成后不用伊始化;

    //2.也正是说可选值在目的协会实现后并非开始化;

    //三.其实假诺不对可选存款和储蓄属性举行开头化, 默许正是nil

    //3.其实假设不对可选存款和储蓄属性举行起始化, 暗中同意正是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 {

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

    //此时既未有提供缺省值, 也未曾提供构造方法, 可是编写翻译通过

    //因为私下认可意况下, 结构体会给结构体提供四个暗许的成员相继构造器

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

    var width:Double = 0.0

    var width:Double = 0.0

    var height:Double = 0.0

    var height:Double = 0.0

    /*

    /*

    // 系统暗中同意会提供2个近乎的法子

    // 系统暗许会提供一个好像的点子

    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

    }

    }

    */

    */

}

}

// 注意: 一.在类中暗中同意是不曾各样构造器的

// 注意: 1.在类中暗许是尚未各类构造器的

// ②.要是在结构体中自定义了构造方法, 那么系统不会变动默许的次第构造器

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

// 三.假如给存款和储蓄属性提供了缺省值, 系统或然会提供暗中认可的顺序构造器

// 3.万1给存款和储蓄属性提供了缺省值, 系统可能会提供暗中同意的逐条构造器

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

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

// 4.若是给存款和储蓄属性提供了缺省值, 可以采用不带参数的不二等秘书技开始化结构体

// 四.壹旦给存储属性提供了缺省值, 能够采纳不带参数的点子起初化结构体

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(“================================”)

 

 

 

 

/*

/*

 通过闭包只怕全局函数/类格局 设置存储属性的缺省值

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

 假若须要通过测算,
恐怕需求进行部分特出的操作才具显然初阶值时就能够通过闭包或全局函数设置存款和储蓄属性的缺省值

 借使急需经过计量,
可能供给开始展览一些附加的操作本事分明初步值时就能够通过闭包或全局函数设置存款和储蓄属性的缺省值

 */

 */

 

 

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  // 这1行能够省略,
重回值是能够总结的,默许再次回到值的档期的顺序就是积存属性的种类

        () -> Int in  // 那一行能够总结,
重回值是足以差不离的,默许重返值的项目正是积累属性的品种

       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

    }()

    }()

    

4858.com,    

    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)

 

 

发表评论

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

网站地图xml地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有