【澳门葡京备用网址】构造方法

  

  

/*

/*

/*

/*

 构造方法:

 构造方法:

 隶属于每二个类或结构体的函数称之为方法:

 隶属于每二个类或结构体的函数称之为方法:

 

 

 方法分为类形式和实例方法, 对应OC中的+ – 方法

 方法分为类措施和实例方法, 对应OC中的+ – 方法

 成效: 对实例对象的内容进行起首化

 效用: 对实例对象的内容进行开端化

 实例方法:实例方法自然是透过对象来调用的, 实例方法隶属于某三个类

 实例方法:实例方法自然是透过对象来调用的, 实例方法隶属于某3个类

 Swift供给类大概结构体中的存款和储蓄属性(非lazy在)在对象组织完成后要有起初化值

 Swift要求类可能结构体中的存款和储蓄属性(非lazy在)在对象组织完成后要有开始化值

 */

 */

 

 

 

 

 语法:

 语法:

class Person  {

class Person  {

 init(参数列表){ 开端化代码 }

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

    var _name: String = “HaRi”

    var _name: String = “HaRi”

 

 

    var _age: Int = 26

    var _age: Int = 26

 注意: 一.在Swift中类/结果提/枚举都急需构造方法;

 注意: 一.在Swift中类/结果提/枚举都亟需构造方法;

    //实例方法自然是经过对象来调用的, 实例方法隶属于某1个类

    //实例方法自然是经过对象来调用的, 实例方法隶属于某三个类

 ②.构造艺术的功效只是是措辞开头化属性, 而不是分配内容,
分配内部存款和储蓄器是系统帮大家做的;

 二.构造措施的成效只是是措辞开首化属性, 而不是分配内容,
分配内部存储器是系统帮大家做的;

    //假若不期望有些参数作为外部参数使用, 能够在参数前面加上 _ ,
忽略外部参数

    //如若不指望某些参数作为外部参数使用, 能够在参数前面加上 _ ,
忽略外部参数

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

 叁.构造方法是隐式调用的, 通过 类名称() 酿成创制一个对象就会隐式调用
init() 构造方法;

    func setName(name: String, _ age: Int)

    func setName(name: String, _ age: Int)

 4.只要具有的仓库储存属性都有默许值, 能够不提供构造方法,
系统会提供1个隐式的构造方法;

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

    {

    {

 5.如若存款和储蓄属性能够提供缺省, 那么提倡我们使用安装缺省值的艺术,
那样能够简化代码(不用自定义构造方法, 不用写存款和储蓄属性类型)

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

        _name = name

        _name = name

 */

 */

        _age = age

        _age = age

 

 

    }

    }

class Person {

class Person {

    func show()

    func show()

    var name: String = “hjq”

    var name: String = “hjq”

    {

    {

//    var age: Int = 20

//    var age: Int = 20

        print(“name = \(_name) age = \(_age)”)

        print(“name = \(_name) age = \(_age)”)

    var age:Int

    var age:Int

    }

    }

    func description() -> String {

    func description() -> String {

}

}

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

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

var p = Person()

var p = Person()

    }

    }

p.show()

p.show()

    init() {

    init() {

 

 

        print(“init”)

        print(“init”)

// 由于第二个参数能够由此艺术名称内定, 所以暗中认可第二个参数不作为外部参数

// 由于第叁个参数能够因此艺术名称内定, 所以默许第三个参数不作为外部参数

        age = 30

        age = 30

//p.setName(name:”xiaoHan”, age:100)    Error!

//p.setName(name:”xiaoHan”, age:100)    Error!

    }

    }

p.setName(name: “hjq”, 8八)  //正确姿势

p.setName(name: “hjq”, 8八)  //正确姿势

}

}

p.show()

p.show()

// 1.分配内部存款和储蓄器; 贰.初叶化name和age; 叁.构造方法是隐式调用的

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

 

 

var p = Person()

var p = Person()

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

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

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

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

//func setName(name:String,myAge age:Int){

//func setName(name:String,myAge age:Int){

print(p.age)

print(p.age)

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

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

 

 

    

    

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

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

}

}

 

 

// 实例方法和函数的差距在于,
实例方法会自动将除第3个参数以外的别的参数既当做为外部参数又作为内部参数,
而函数必要大家协调钦点才会有表面参数, 暗中认可未有

// 实例方法和函数的差距在于,
实例方法会自动将除第3个参数以外的其它参数既当做为外部参数又作为内部参数,
而函数须要大家友好钦赐才会有表面参数, 暗许未有

 

 

setName(name: “han”, age: 30)

setName(name: “han”, age: 30)

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

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

 

 

class Person2 {

class Person2 {

/*

/*

    var name:String

    var name:String

 self关键字, 斯维夫特中的self和OC中的self基本1致; self指当前线指挥部标,
self在目的方法中代表当前目的, 不过在类措施中尚无self

 self关键字, Swift中的self和OC中的self基本一致; self指当前线指挥部标,
self在对象方法中意味着当前目的, 可是在类格局中尚无self

    var age:Int

    var age:Int

 */

 */

    func description() -> String {

    func description() -> String {

class Person2 {

class Person2 {

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

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

    var name: String = “hjq”

    var name: String = “hjq”

    }

    }

    var age: Int = 25

    var age: Int = 25

    //一.构造方法的当中参数, 私下认可也是外部参数;

    //一.构造方法的内部参数, 默许也是表面参数;

    

    

    //2.而函数的里边参数私下认可不会作为外部参数;

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

    //当参数名称和特性名称一模同样时, 无法区分哪些是参数哪个是性质,
这年能够因而self明显的来区分参数和总体性

    //当参数名称和品质名称1模同样时, 不能区分哪些是参数哪个是性质,
那个时候能够透过self明显的来区分参数和本性

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

    //三.而艺术的里边参数, 从第2个开端才会作为外部参数;

    func setName(name: String, age: Int)

    func setName(name: String, age: Int)

    //四.构造方法对品质的顺序未有必要,
只要有限扶助对象协会完时全体存款和储蓄属性被起始化就能够.

    //肆.构造方法对质量的逐条没有须求,
只要保险对象协会完时全数存款和储蓄属性被开首化就可以.

    {

    {

    init(age:Int, name:String)

    init(age:Int, name:String)

        //私下认可情形下, _name和_age后面私下认可有3个self关键字,
因为具备变量都急需先定义再利用,
而setName方法中并不曾概念过_name和_age, 而是在质量中定义的,
所以setName中做客的莫过于是性质, 编写翻译器暗许帮大家在前方加了二个self

        //默许意况下, _name和_age后边默许有二个self关键字,
因为具备变量都亟待先定义再利用,
而setName方法中并从未定义过_name和_age, 而是在品质中定义的,
所以setName中访问的其实是性质, 编写翻译器暗中同意帮大家在前头加了三个self

    {

    {

//        _name = name

//        _name = name

        self.name = name

        self.name = name

//        _age = age

//        _age = age

        self.age = age

        self.age = age

        self.name = name

        self.name = name

    }

    }

        self.age = age

        self.age = age

【澳门葡京备用网址】构造方法。    func setName(name:String, age:Int)

    func setName(name:String, age:Int)

    }

    }

    {

    {

    func show()

    func show()

        self.name = name

        self.name = name

    {

    {

        self.age = age

        self.age = age

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

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

    }

    }

    }

    }

}

}

}

}

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

 mutating方法

 mutating方法

 

 

 值类型(结构体和枚举)私下认可方法是不得以修改属性的, 要是要求修改属性,
须求在情势前增进mutating关键字, 让该形式成为二个改造方法

 值类型(结构体和枚举)暗中同意方法是无法修改属性的, 如若需求修改属性,
须要在点子前增加mutating关键字, 让该措施成为二个改动方法

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

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

 */

 */

print(p2.description())

print(p2.description())

struct Person3 {

struct Person3 {

 

 

    var name: String = “hjq”

    var name: String = “hjq”

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

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

    var age: Int = 24

    var age: Int = 24

 

 

    //值类型(结构体和枚举)暗中认可方法是不得以修改属性的, 要是须要修改属性,
须要在措施前增进mutating关键字, 让该办法成为2个更改方法

    //值类型(结构体和枚举)暗许方法是不得以修改属性的, 固然要求修改属性,
要求在格局前增进mutating关键字, 让该方法成为一个改换方法

/*

/*

    //注意: 类不供给, 因为类的实例方法私下认可就足以修改

    //注意: 类不须要, 因为类的实例方法暗许就足以修改

 常量存储属性与构造方法

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

    mutating func setName(name: String, age: Int)

    mutating func setName(name: String, age: Int)

 常量存款和储蓄属性只可以通过缺省值或在构造方法中被修改, 其余任啥地点方都不能够改改

 常量存款和储蓄属性只好通过缺省值或在构造方法中被更动, 其它任哪个地方方都不能够改改

    {

    {

 */

 */

        self.name = name

        self.name = name

class Person3 {

class Person3 {

        self.age = age

        self.age = age

    var name:String = “hjq”

    var name:String = “hjq”

    }

    }

    var age:Int

    var age:Int

    func show()

    func show()

    init(age:Int, name:String)

    init(age:Int, name:String)

    {

    {

    {

    {

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

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

        self.name = name

        self.name = name

    }

    }

        self.age = age

        self.age = age

}

}

    }

    }

var p3 = Person3()

var p3 = Person3()

    func description() -> String {

    func description() -> String {

p3.setName(name: “han”, age: 100)

p3.setName(name: “han”, age: 100)

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

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

p3.show()

p3.show()

    }

    }

 

 

}

}

 

 

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

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

enum LightSwitch {

enum LightSwitch {

print(p3.description())

print(p3.description())

    case OFF, ON

    case OFF, ON

//p三.name = “hello” //常量存款和储蓄属性初叶化之后分裂意被修改!
虽没报错,不过不一致意,那一点在前边开荒中发掘验证!

//p三.name = “hello” //常量存款和储蓄属性开端化之后不允许被改换!
虽没报错,但是不容许,那点在背后开采中开掘验证!

    mutating func next()

    mutating func next()

 

 

    {

    {

 

 

        switch self {

        switch self {

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

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

        case .OFF:

        case .OFF:

 

 

            self = .ON

            self = .ON

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

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

        case .ON:

        case .ON:

 

 

            self = .OFF

            self = .OFF

class Car {

class Car {

        }

        }

    let name:String

    let name:String

    }

    }

    init(name:String)

    init(name:String)

}

}

    {

    {

var ls:LightSwitch = .OFF

var ls:LightSwitch = .OFF

        self.name = name

        self.name = name

if ls == LightSwitch.OFF

if ls == LightSwitch.OFF

    }

    }

{

{

}

}

    print(“off”)

    print(“off”)

class Person4 {

class Person4 {

}

}

    let name:String

    let name:String

ls.next()

ls.next()

    var age:Int

    var age:Int

if ls == LightSwitch.ON

if ls == LightSwitch.ON

    var car:Car?

    var car:Car?

{

{

    

    

    print(“on”)

    print(“on”)

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

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

}

}

    //2.也等于说可选值在目的组织实现后不要开端化;

    //二.也便是说可选值在目的组织完成后不要伊始化;

 

 

    //三.其实借使不对可选存款和储蓄属性举行伊始化, 默许正是nil

    //三.其实假如不对可选存款和储蓄属性进行伊始化, 暗中同意便是nil

 

 

    init(age:Int, name:String)

    init(age:Int, name:String)

/*

/*

    {

    {

 类方法:

 类方法:

        self.age = age

        self.age = age

 和类属性同样通过类名来调用, 类方法通过static关键字(结构体/枚举),
class(类)

 和类属性同样通过类名来调用, 类方法通过static关键字(结构体/枚举),
class(类)

        self.name = name

        self.name = name

 类方法中不存在self

 类方法中不存在self

    }

    }

 */

 */

    func description() -> String {

    func description() -> String {

 

 

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

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

struct Person4 {

struct Person4 {

    }

    }

    var name: String = “HanJunqiang”

    var name: String = “HanJunqiang”

}

}

    static var card: String = “1234567”

    static var card: String = “1234567”

 

 

    func show()

    func show()

 

 

    {

    {

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

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

        print(“name = \(name) card = \(Person4.card)”)

        print(“name = \(name) card = \(Person4.card)”)

struct Rect {

struct Rect {

    }

    }

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

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

    static func staticShow()

    static func staticShow()

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

    //因为暗许情况下, 结构体会给结构体提供1个暗中认可的分子相继构造器

    {

    {

    var width:Double = 0.0

    var width:Double = 0.0

        //类方法中绝非self

        //类方法中从不self

    var height:Double = 0.0

    var height:Double = 0.0

澳门葡京备用网址,        //静态方法对应OC中的+号方法,
和OC同样在类方式中不可能访问非静态属性

        //静态方法对应OC中的+号方法,
和OC同样在类方式中不能够访问非静态属性

    /*

    /*

        print(“card = \(Person4.card)”)

        print(“card = \(Person4.card)”)

    // 系统默许会提供三个看似的措施

    // 系统暗中同意会提供三个近似的格局

    }

    }

    init(width:Double, height:Double)

    init(width:Double, height:Double)

}

}

    {

    {

var p4 = Person4()

var p4 = Person4()

        self.width = width

        self.width = width

p4.show()

p4.show()

        self.height = height

        self.height = height

Person4.staticShow()

Person4.staticShow()

    }

    }

 

 

    */

    */

    /*

    /*

    init() {

    init() {

        self.width = 0.0

        self.width = 0.0

        self.height = 0.0

        self.height = 0.0

    }

    }

    */

    */

}

}

// 注意: 一.在类中暗中同意是绝非各类构造器的

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

// 2.万1在结构体中自定义了构造方法, 那么系统不会转移私下认可的各样构造器

// 二.就算在结构体中自定义了构造方法, 那么系统不会变卦私下认可的顺序构造器

// 叁.万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  // 那壹行能够省略,
重临值是能够省略的,私下认可再次回到值的品种正是储存属性的品种

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

    }()

    }()

    

    

    var age2:Int = getValue()

    var age2:Int = getValue()

    var age3:Int = Person5.getValue2()

    var age3:Int = Person5.getValue2()

    

    

    //1.不能这样写, 因为调用方法时对象还从未早先化完结;

    //1.不能够这样写, 因为调用方法时对象还尚无开端化完成;

    //二.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