构造方法

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

  

  

/*

/*

/*

/*

 构造方法:

 构造方法:

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

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

 

 

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

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

 功能: 对实例对象的内容实行初步化

 效率: 对实例对象的内容实行初步化

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

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

 斯维夫特供给类只怕结构体中的存款和储蓄属性(非lazy在)在目的组织完结后要有起头化值

 斯威夫特必要类可能结构体中的存款和储蓄属性(非lazy在)在目的组织达成后要有伊始化值

 */

 */

 

 

 

 

 语法:

 语法:

class Person  {

class Person  {

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

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

    var _name: String = “HaRi”

    var _name: String = “HaRi”

 

 

    var _age: Int = 26

    var _age: Int = 26

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

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

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

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

 贰.构造艺术的效果只是是措辞发轫化属性, 而不是分配内容,
分配内存是系统帮大家做的;

 贰.构造措施的意义只是是措辞伊始化属性, 而不是分配内容,
分配内部存款和储蓄器是系统帮大家做的;

    //假若不期待有个别参数作为外部参数使用, 能够在参数前边加上 _ ,
忽略外部参数

    //假如不愿意某些参数作为外部参数使用, 能够在参数前边加上 _ ,
忽略外部参数

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

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

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

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

 四.只要持有的仓库储存属性都有暗中同意值, 能够不提供构造方法,
系统会提供2个隐式的构造方法;

 肆.借使具有的积攒属性都有暗中认可值, 能够不提供构造方法,
系统会提供叁个隐式的构造方法;

    {

    {

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

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

// 由于第1个参数能够透过措施名称钦命, 所以暗中同意第3个参数不作为外部参数

// 由于第贰个参数能够透过措施名称钦命, 所以暗中认可第二个参数不作为外部参数

        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”, 88)  //正确姿势

}

}

p.show()

p.show()

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

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

 

 

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个参数以外的别样参数既当做为外部参数又作为内部参数,
而函数要求大家友好钦赐才会有外部参数, 暗许未有

 

 

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

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

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

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

 

 

class Person2 {

class Person2 {

/*

/*

    var name:String

    var name:String

 self关键字, Swift中的self和OC中的self基本同样; 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

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

    //1.构造方法的里边参数, 暗中同意也是外部参数;

    

    

    //贰.而函数的中间参数私下认可不会作为外部参数;

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

    //当参数名称和属性名称壹模一样时, 不可能区分哪些是参数哪个是性质,
那一年能够由此self明显的来分别参数和性质

    //当参数名称和总体性名称1模一样时, 无法区分哪些是参数哪个是性质,
那一年能够经过self显著的来区分参数和属性

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

    //三.而艺术的中间参数, 从第3个伊始才会作为外部参数;

    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中访问的其实是性质, 编写翻译器暗中认可帮咱们在日前加了3个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关键字, 让该情势成为3个改造方法

    //值类型(结构体和枚举)默许方法是无法修改属性的, 要是须要修改属性,
必要在艺术前拉长mutating关键字, 让该措施成为3个改造方法

/*

/*

    //注意: 类不需求, 因为类的实例方法默许就能够修改

    //注意: 类不须求, 因为类的实例方法暗许即可修改

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

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

    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

4858.com ,        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()

    //因为私下认可处境下, 结构体会给结构体提供2个暗许的分子相继构造器

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

    {

    {

    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

    }

    }

    */

    */

}

}

// 注意: 1.在类中暗中同意是未有各种构造器的

// 注意: 一.在类中暗中认可是从未各样构造器的

// 2.万1在结构体中自定义了构造方法, 那么系统不会调换暗中认可的逐条构造器

// 二.尽管在结构体中自定义了构造方法, 那么系统不会生成默许的相继构造器

// 三.一旦给存款和储蓄属性提供了缺省值, 系统或许会提供私下认可的逐条构造器

// 三.纵然给存款和储蓄属性提供了缺省值, 系统或许会提供默许的相继构造器

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

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

// 4.一旦给存款和储蓄属性提供了缺省值, 能够选取不带参数的措施开头化结构体

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

    }()

    }()

    

    

    var age2:Int = getValue()

    var age2:Int = getValue()

    var age3:Int = Person5.getValue2()

    var age3:Int = Person5.getValue2()

    

    

    //一.无法如此写, 因为调用方法时对象还未曾伊始化落成;

    //一.不可能那样写, 因为调用方法时对象还尚未开首化达成;

    //2.self唯有当有着的积攒属性都伊始化达成之后才能够用.

    //2.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 版权所有