当前位置: 澳门新濠3559 > 编程 > 正文

澳门新濠35591.在Swift中类/结果提/枚举都需要构造

时间:2019-11-01 13:15来源:编程
   /* /*  构造方法:  附属于每二个类或结构体的函数称之为方法:    方法分为类方式和实例方法, 对应OC中的+ - 方法  功能: 对实例对象的从头到尾的经过张开初始化  实例方法:实例

  

/*

/*

 构造方法:

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

 

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

 功能: 对实例对象的从头到尾的经过张开初始化

 实例方法:实例方法自然是因此对象来调用的, 实例方法从属于某一个类

 Swift须要类只怕结构体中的存款和储蓄属性(非lazy在)在对象协会完结后要有最初化值

 */

 

 

 语法:

class Person  {

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

    var _name: String = "HaRi"

 

    var _age: Int = 26

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

    //实例方法自然是透过对象来调用的, 实例方法附属于某四个类

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

    //假诺不指望有些参数作为外界参数使用, 可以在参数前边加上 _ , 忽视外界参数

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

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

 4.假诺持有的积攒属性都有暗中认可值, 能够不提供构造方法, 系统会提供一个隐式的构造方法;

    {

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

        _name = name

 */

        _age = age

 

    }

class Person {

    func show()

    var name: String = "hjq"

    {

//    var age: Int = 20

        print("name = (_name) age = (_age)")

    var age:Int

    }

    func description() -> String {

}

        return "name = (name) age = (age)"

var p = Person()

    }

p.show()

    init() {

 

        print("init")

// 由于第二个参数能够通过措施名称钦命, 所以默许第三个参数不作为外界参数

        age = 30

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

    }

p.setName(name: "hjq", 88)  //精确姿势

}

p.show()

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

 

var p = Person()

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

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

澳门新濠35591.在Swift中类/结果提/枚举都需要构造方法, 实例方法。//func setName(name:String,myAge age:Int){

print(p.age)

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

 

    

print("================================")

}

 

// 实例方法和函数的界别在于, 实例方法会自动将除第八个参数以外的别样参数既当做为外界参数又作为内部参数, 而函数需求我们自个儿内定才会有外界参数, 暗中同意未有

 

setName(name: "han", age: 30)

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

 

class Person2 {

/*

    var name:String

 self关键字, 斯威夫特中的self和OC中的self基本雷同; self指当前指标, self在指标方法中意味当前目的, 不过在类形式中从不self

    var age:Int

 */

    func description() -> String {

class Person2 {

        return "name = (name) age = (age)"

    var name: String = "hjq"

    }

    var age: Int = 25

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

    

    //2.而函数的当中参数暗中同意不会作为外界参数;

    //当参数名称和属性名称一模二样时, 不可能区分哪些是参数哪个是性质, 那时候可以透过self显明的来分别参数和性质

    //3.而艺术的内部参数, 从第一个开头才会作为外界参数;

    func setName(name: String, age: Int)

    //4.构造方法对性能的相继未有要求, 只要保险对象组织完时全数存款和储蓄属性被开始化就可以.

    {

    init(age:Int, name:String)

        //暗许情状下, _name和_age前面暗中同意有一个self关键字, 因为兼具变量都急需先定义再使用, 而setName方法中并不曾概念过_name和_age, 而是在质量中定义的, 所以setName中做客的莫过于是性质, 编写翻译器默许帮大家在日前加了一个self

    {

//        _name = name

        self.name = name

//        _age = age

        self.age = age

        self.name = name

    }

        self.age = age

    func setName(name:String, age:Int)

    }

    {

    func show()

        self.name = name

    {

        self.age = age

        print("name = (name) age = (age)")

    }

    }

}

}

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

 

p2.setName(name: "hjq", age: 30)

/*

print(p2.description())

 mutating方法

 

 值类型(结构体和枚举)私下认可方法是不得以修正属性的, 假如要求修改属性, 供给在章程前拉长mutating关键字, 让该格局成为二个校订方法

p2.setName(name: "hjq", age: 23)

 */

print(p2.description())

struct Person3 {

 

    var name: String = "hjq"

print("================================")

    var age: Int = 24

 

    //值类型(结构体和枚举)暗中认可方法是不可能修改属性的, 就算须求改革属性, 须要在方式前增进mutating关键字, 让该措施成为三个改动方法

/*

    //注意: 类没有要求, 因为类的实例方法私下认可就足以修正

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

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

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

    {

 */

        self.name = name

class Person3 {

        self.age = age

    var name:String = "hjq"

    }

    var age:Int

    func show()

    init(age:Int, name:String)

    {

    {

        print("name = (name) age = (age)")

        self.name = name

    }

        self.age = age

}

    }

var p3 = Person3()

    func description() -> String {

p3.setName(name: "han", age: 100)

        return "name = (name) age = (age)"

p3.show()

    }

 

}

 

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

enum LightSwitch {

print(p3.description())

    case OFF, ON

//p3.name = "hello" //常量存款和储蓄属性开端化之后分化意被涂改! 虽没报错,不过差异意,这点在背后开垦中开采验证!

    mutating func next()

 

    {

 

        switch self {

print("================================")

        case .OFF:

 

            self = .ON

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

        case .ON:

 

            self = .OFF

class Car {

        }

    let name:String

    }

    init(name:String)

}

    {

var ls:LightSwitch = .OFF

        self.name = name

if ls == LightSwitch.OFF

    }

{

}

    print("off")

class Person4 {

}

    let name:String

ls.next()

    var age:Int

if ls == LightSwitch.ON

    var car:Car?

{

    

    print("on")

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

}

    //2.也等于说可选值在指标协会完结后不用初叶化;

 

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

 

    init(age:Int, name:String)

/*

    {

 类方法:

        self.age = age

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

        self.name = name

 类方法中荒诞不经self

    }

 */

    func description() -> String {

 

        return "name = (name) age = (age)"

struct Person4 {

    }

    var name: String = "HanJunqiang"

}

    static var card: String = "1234567"

 

    func show()

 

    {

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

        print("name = (name) card = (Person4.card)")

struct Rect {

    }

    //那个时候既没有提供缺省值, 也一直不提供构造方法, 不过编写翻译通过

    static func staticShow()

    //因为暗许意况下, 结构体会给结构体提供多个默许的积极分子相继构造器

    {

    var width:Double = 0.0

        //类方法中未有self

    var height:Double = 0.0

        //静态方法对应OC中的+号方法, 和OC雷同在类情势中不可能访谈非静态属性

    /*

        print("card = (Person4.card)")

    // 系统默许会提供一个肖似的方法

    }

    init(width:Double, height:Double)

}

    {

var p4 = Person4()

        self.width = width

p4.show()

        self.height = height

Person4.staticShow()

    }

 

    */

    /*

    init() {

        self.width = 0.0

        self.height = 0.0

    }

    */

}

// 注意: 1.在类中暗中认可是绝非种种构造器的

// 2.假使在结构体中自定义了构造方法, 那么系统不会变动暗许的逐生机勃勃构造器

// 3.只要给存款和储蓄属性提供了缺省值, 系统可能会提供暗中认可的次第构造器

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

// 4.举个例子给存款和储蓄属性提供了缺省值, 能够行使不带参数的章程初步化结构体

var r = Rect()

 

 

/*

 "值类型"的构造器代理

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

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

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

 */

 

struct Rect2 {

    var width:Double, height:Double

    init(width:Double, height:Double)

    {

        self.width = width

        self.height = height

    }

    init()

    {

//        self.width = 0.0

//        self.height = 0.0

        //构造器代理

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

    }

    func show()

    {

        print("width = (width) height = (height)")

    }

}

var r2 = Rect2()

r2.show()

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

r3.show()

 

 

print("================================")

 

 

/*

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

 要是急需经过计算, 或许须求开展局地额外的操作技巧鲜明起头值时就足以经过闭包或全局函数设置存款和储蓄属性的缺省值

 */

 

func getValue() ->Int

{

    print("getValue")

    return 55

}

class Person5 {

    var name:String

    

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

    //注意: 闭包前边明确要有(), 代表试行闭包

    var age:Int = {

        () -> Int in  // 那生龙活虎行能够回顾, 重返值是能够大致的,暗中同意再次回到值的项目就是积攒属性的品种

       print("age 闭包")

        return 30

    }()

    

    lazy var height:Double = {

      print("lzay 闭包")

        return 180.0

    }()

    

    var age2:Int = getValue()

    var age3:Int = Person5.getValue2()

    

    //1.不能够那样写, 因为调用方法时对象还不曾开始化完结;

    //2.self独有当全部的囤积属性都初阶化实现之后才方可用.

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

    

    init(name:String) {

        self.name = name

    }

    class func getValue2() ->Int {

        print("class getValue2")

        return 100

    }

    func getValue3() -> Int {

        return 99

    }

}

var p5 = Person5(name: "hjq")

//懒加载是用到才实行, 而闭包赋值是开头化时就能实践

print(p5.height)

 

编辑:编程 本文来源:澳门新濠35591.在Swift中类/结果提/枚举都需要构造

关键词: