• 构造过程 (Initialization) 1.存储类型的初始赋值 类和结构在创建实例的时候,必须为所有的存储属性设置值,不能为nil 1.1构造器 构造器在创建某个特定类型的新实例的时候调用,最简形式类似不带参数的...

    构造过程 (Initialization)

    1.存储类型的初始赋值

    类和结构在创建实例的时候,必须为所有的存储属性设置值,不能为nil

    1.1构造器

    构造器在创建某个特定类型的新实例的时候调用,最简形式类似不带参数的方法,以init命名
    struct Fahrenheit {
        var temperature: Double
        init() {
            temperature = 32.0
        }
    }
    var f = Fahrenheit()
    println("The default temperature is \(f.temperature)° Fahrenheit")
    // prints "The default temperature is 32.0° Fahrenheit"

    1.2默认属性值

    在属性生命的时候直接为其设置默认值
    struct Fahrenheit {
        var temperature = 32.0
    }

    2.定制化构造过程

    2.1构造参数

    在定义构造器的时候提供构造参数,语法跟函数和方法相同
    struct Celsius {
        var temperatureInCelsius: Double = 0.0
        init(fromFahrenheit fahrenheit: Double) {
            temperatureInCelsius = (fahrenheit - 32.0) / 1.8
        }
        init(fromKelvin kelvin: Double) {
            temperatureInCelsius = kelvin - 273.15
        }
    }
    let boilingPointOfWater = Celsius(fromFahrenheit: 212.0)
    // boilingPointOfWater.temperatureInCelsius is 100.0
    let freezingPointOfWater = Celsius(fromKelvin: 273.15)
    // freezingPointOfWater.temperatureInCelsius is 0.0

    2.2内部和外部参数名

    构造函数存在一个构造器内部使用的参数名和一个在调用时使用的外部参数名,如果没有提供参数的外部名字,Swift会自动为每个构造器的参数生成一个跟内部参数名相同的外部参数名
    struct Color {
        let red = 0.0, green = 0.0, blue = 0.0
        init(red: Double, green: Double, blue: Double) {
            self.red   = red
            self.green = green
            self.blue  = blue
        }
    }
    let magenta = Color(red: 1.0, green: 0.0, blue: 1.0)
    // 如果不通过外部参数名传值,编译时无法通过
    let veryGreen = Color(0.0, 1.0, 0.0)
    // this reports a compile-time error - external names are required

    2.3可选属性类型

    如果定义的类型包含一个可以为空的存储型属性,需要将其定义为可选类型 (optional type), 则自动初始化为nil,表示这个属性是故意初始化设置为空的
    class SurveyQuestion {
        var text: String
        var response: String?
        init(text: String) {
            self.text = text
        }
        func ask() {
            println(text)
        }
    }
    let cheeseQuestion = SurveyQuestion(text: "Do you like cheese?")
    cheeseQuestion.ask()
    // prints "Do you like cheese?"
    cheeseQuestion.response = "Yes, I do like cheese."

    2.4构造过程中常量的修改

    只要在构造过程结束后能确定常量的值,就可以在构造过程之中随意修改常量的值
    // 尽管text属性是常量,但在构造过程之中还是可以修改的,构造过程结束时候不能再修改了
    class SurveyQuestion {
        let text: String
        var response: String?
        init(text: String) {
            self.text = text
        }
        func ask() {
            println(text)
        }
    }
    let beetsQuestion = SurveyQuestion(text: "How about beets?")
    beetsQuestion.ask()
    // prints "How about beets?"
    beetsQuestion.response = "I also like beets. (But not with cheese.)"

    3.默认构造器

    Swift为素有属性已提供默认值的但自身没有构造器的结构体或基类提供一个默认的构造器,构造器创建一个将所有属性值都设置为默认值的实例
    class ShoppingListItem {
        var name: String?
        var quantity = 1
        var purchased = false
    }
    var item = ShoppingListItem()
    
    
    struct Size {
        var width = 0.0, height = 0.0
    }
    let twoByTwo = Size(width: 2.0, height: 2.0)

    4.值类型的构造器代理

    构造器通过调用其他构造器来完成实例的部分构造,提高代码利用率,称为构造器的代理
    struct Size {
        var width = 0.0, height = 0.0
    }
    struct Point {
        var x = 0.0, y = 0.0
    }
    struct Rect {
        var origin = Point()
        var size = Size()
        init() {}
        init(origin: Point, size: Size) {
            self.origin = origin
            self.size = size
        }
        init(center: Point, size: Size) {
            let originX = center.x - (size.width / 2)
            let originY = center.y - (size.height / 2)
            self.init(origin: Point(x: originX, y: originY), size: size)
        }
    }
    let basicRect = Rect()
    // basicRect's origin is (0.0, 0.0) and its size is (0.0, 0.0)
    
    let originRect = Rect(origin: Point(x: 2.0, y: 2.0),
        size: Size(width: 5.0, height: 5.0))
    // originRect's origin is (2.0, 2.0) and its size is (5.0, 5.0)
    

    5.类的继承和构造过程

    类里所有的存储类型属性包括继承父类的属性都需要在构造过程中设置初始值,Swift提供两种类型的类构造器来确保所有类实例中的存储属性都能获得初始值

    5.1指定构造器和便利构造器

    指定构造器是类中最主要的构造器,将初始化类中所提供的所有属性,每个类至少需要一个指定构造器,便利构造器是辅助型的构造器,可调用同一类中的指定构造器,并为其参数提供默认值

    5.2构造器链

    Swift采用三条规则来限制构造器之间的代理调用
    a.指定构造器必须调用其直接父类的指定构造器
    b.便利构造器必须调用同一类中定义的其他构造器
    c.便利构造器最终必须调用一个指定构造器结束
    (指定构造器总是向上代理,便利构造器总是横向代理)

    5.3构造器的继承和重载

    Swift中的子类默认不会继承父类的构造器,防止父类的简单构造被子类继承,并错误的创建子类的实例,如果希望子类能继承父类相同的构造器,需要定制子类的构造器

    5.4指定构造器和便利构造器的语法

    init(parameters) {
        statements
    }
    // 便利构造器前置 convenience关键字
    convenience init(parameters) {
        statements
    }
    
    class Food {
        var name: String
        init(name: String) {
            self.name = name
        }
        convenience init() {
            self.init(name: "[Unnamed]")
        }
    }
    
    let namedMeat = Food(name: "Bacon")
    // namedMeat's name is "Bacon"
    
    let mysteryMeat = Food()
    // mysteryMeat's name is "[Unnamed]"
    
    class RecipeIngredient: Food {
        var quantity: Int
        init(name: String, quantity: Int) {
            self.quantity = quantity
            super.init(name: name)
        }
        convenience init(name: String) {
            self.init(name: name, quantity: 1)
        }
    }
    
    let oneMysteryItem = RecipeIngredient()
    let oneBacon = RecipeIngredient(name: "Bacon")
    let sixEggs = RecipeIngredient(name: "Eggs", quantity: 6)
    
    class ShoppingListItem: RecipeIngredient {
        var purchased = false
        var description: String {
        var output = "\(quantity) x \(name.lowercaseString)"
            output += purchased ? " ✔" : " ✘"
            return output
        }
    }
    
    var breakfastList = [
        ShoppingListItem(),
        ShoppingListItem(name: "Bacon"),
        ShoppingListItem(name: "Eggs", quantity: 6),
    ]
    breakfastList[0].name = "Orange juice"
    breakfastList[0].purchased = true
    for item in breakfastList {
        println(item.description)
    }
    // 1 x orange juice ✔
    // 1 x bacon ✘
    // 6 x eggs ✘
    

    6.通过闭包和函数来设置属性的默认值

    属性可以使用闭包或全局函数来提供默认值,当创建新实例时,对应的闭包或函数就会被调用,返回值当做这个属性的默认值
    //闭包结尾的大括号后接空得小括号,告诉Swift立刻执行此闭包,如果忽略这个括号,相当于闭包本身作为值赋给属性,而不是将闭包的返回值赋给属性
    class SomeClass {
        let someProperty: SomeType = {
            // create a default value for someProperty inside this closure
            // someValue must be of the same type as SomeType
            return someValue
            }()
    }
    
    struct Checkerboard {
        let boardColors: Bool[] = {
            var temporaryBoard = Bool[]()
            var isBlack = false
            for i in 1...10 {
                for j in 1...10 {
                    temporaryBoard.append(isBlack)
                    isBlack = !isBlack
                }
                isBlack = !isBlack
            }
            return temporaryBoard
            }()
        func squareIsBlackAtRow(row: Int, column: Int) -> Bool {
            return boardColors[(row * 10) + column]
        }
    }
    
    let board = Checkerboard()
    println(board.squareIsBlackAtRow(0, column: 1))
    // prints "true"
    println(board.squareIsBlackAtRow(9, column: 9))
    // prints "false"


    析构过程 (Deinitialization)

    类的实例被释放之前,析构函数被立即调用,deinit表示析构过程

    1.原理

    Swift会自动释放不需要的实例以释放资源,但当使用自己的资源的时候,需要清理额外的信息,如创建一个自定义的类来打开文件并写入数据,可能需要在类实例被释放之前关闭该文件
    每个类组多只有一个析构函数,不允许主动调用,在实例被释放的前一步被自动调用,因为析构函数知道实例被释放才会被调用,所以可以访问实例的所有属性,并进行操作
    deinit {
        // perform the deinitialization
    }

    2.操作

    struct Bank {
        static var coinsInBank = 10_000
        static func vendCoins(var numberOfCoinsToVend: Int) -> Int {
            numberOfCoinsToVend = min(numberOfCoinsToVend, coinsInBank)
            coinsInBank -= numberOfCoinsToVend
            return numberOfCoinsToVend
        }
        static func receiveCoins(coins: Int) {
            coinsInBank += coins
        }
    }
    
    
    class Player {
        var coinsInPurse: Int
        init(coins: Int) {
            coinsInPurse = Bank.vendCoins(coins)
        }
        func winCoins(coins: Int) {
            coinsInPurse += Bank.vendCoins(coins)
        }
        deinit {
            Bank.receiveCoins(coinsInPurse)
        }
    }
    
    
    var playerOne: Player? = Player(coins: 100)
    println("A new player has joined the game with \(playerOne!.coinsInPurse) coins")
    // prints "A new player has joined the game with 100 coins"
    println("There are now \(Bank.coinsInBank) coins left in the bank")
    // prints "There are now 9900 coins left in the bank"
    
    
    playerOne!.winCoins(2_000)
    println("PlayerOne won 2000 coins & now has \(playerOne!.coinsInPurse) coins")
    // prints "PlayerOne won 2000 coins & now has 2100 coins"
    println("The bank now only has \(Bank.coinsInBank) coins left")
    // prints "The bank now only has 7900 coins left"
    
    
    playerOne = nil
    println("PlayerOne has left the game")
    // prints "PlayerOne has left the game"
    println("The bank now has \(Bank.coinsInBank) coins")
    // prints "The bank now has 10000 coins"


    展开全文
  • class man { var name : String init (name: String){ self.name = name } }//继承自man class xiaoming:man { var age : NSInteger init(name: String , age:NSInteger) { //这里属性
    <pre name="code" class="objc">class man {
        var name : String
        init (name: String){
            self.name = name
        }
    }
    //继承自man
    class xiaoming:man {
        var age : NSInteger
        init(name: String , age:NSInteger) {
            //这里属性赋值与调用父类的构造器方法 位置不能互换, 必须先把自身的某些特殊属性进行初始化 再调用父类构造函数 才能完成自身的初始化 进而可以对属性进行赋值操作
            self.age = age
            super.init (name: name)
        }
        //便利构造器
        convenience override init(name:String){
            //便利构造器 必须调用本类中的其他指定构造器,然后才能对属性赋值.
    //原因很简单就是如果先对属性进行赋值在调用构造器的话, 那么构造器会把便利构造器刚赋的新值覆盖掉
            self.init(name:name,age:20)
        }
    }
    var xiao = xiaoming.init(name:"xiaoming", age: 18)
    var lei = xiaoming.init(name: "雷")


    
    
    展开全文
  • 1.命名空间 在同一个项目中,所有的类都是共享的,可以直接访问,...Swift支持函数重载,所有构造函数都是init 作用: 分配空间,设置初始值 ** 注意 Object-c的初始化,是从类继承关系链,从父类开始逐级向子类初始化...

    1.命名空间

    • 在同一个项目中,所有的类都是共享的,可以直接访问,不用import
    • 不同的项目中有相同的类,是可以共存的

    2.构造函数

    • 是一种特俗的函数
    • 主要用来在创建对象时,初始化对象
    • 给对象的成员变量设置初始值
    • Swift支持函数重载,所有构造函数都是init
    • 作用: 分配空间,设置初始值

    ** 注意

    • Object-c的初始化,是从类继承关系链,从父类开始逐级向子类初始化
    • Swift的初始化,是先从子类开始,逐级向父类初始化

    • 非optonal属性,都必须在构造函数中设置初始值,从而保证对象再被实例化的时候,属性都被正确地初始化

    • 在调用父类构造函数之前,必须保证本类的属性已经完成初始化
    • Swift中的构造函数不用写func关键字

      1.构造函数的目的是: 给自己的属性分配空间并且设置初始值
      2.调用父类构造函数之前,需要先给本类的属性设置初始值
      3.调用父类的构造函数,给父类的属性分配空间并设置初始值
      4.如果重载了构造函数,并且没有实现父类的init方法,系统不再提供init函数(默认会提供的),
      5.默认的构造函数不能给本类的属性分配空间

    3.重载与重写

    重载: overload

    • 函数名相同
    • 参数类型和个数不同
    • 如果重载了构造函数,并没有实现父类的init方法,系统不再提供init()构造函数
    • 默认的init()构造函数,不能给本类的属性分配空间

    重写: override

    • 父类中已存在此方法
    • 子类重新实现父类的方法
    class ZYImage: NSObject {
    
        var name:String
    
        //重写
        override init() {
            name = "zhouyu"
            super.init()
        }
    
        //重载
        init(name: String) {
            self.name = name
            super.init()
        }
    }
    
        override func viewDidLoad() {
            super.viewDidLoad()
    
            let image = ZYImage()
            print(image.name)
    
            let image2 = ZYImage(name: "wangwu")
            print(image2.name)
        }

    4. KVC构造函数

    要搞清一个问题

    • iOS开发中,很多类的属性都是需要用到的时候才创建的,所以是可选的
    • 定义模型属性时,如果是对象,通常是可选的: 需要的时候才创建,延迟加载,避免写构造函数 例如: var name: String?

    KVC 是 OC 特有的,KVC 本质上是在运行时,动态向对象发送 setValue:ForKey: 方法,为对象的属性设置数值.
    - 因此,在使用 KVC 方法之前,需要确保对象已经被正确实例化.
    - 必选属性必须在调用父类构造函数之前完成初始化分配工作


    • 基本数据类型在Swift ,与KVC不兼容

    如果基本数据类型为nil,KVC在调用 setValue(value: AnyObject?, forKey key: String) 找不到这个属性, 使用KVC时给基本数据类型设置初始值
    import UIKit
    
    class Person: NSObject {
        /// 姓名
        var name: String?
        /// 年龄
        var age: Int = 0
    
        /// `重写`构造函数
        ///
        /// - parameter dict: 字典
        /// - returns: Person 对象
        init(dict: [String: Any]) {
            super.init()
            setValuesForKeys(dict)
        }
    
        override func setValue(_ value: Any?, forKey key: String) {
            print("\(key) \(String(describing: value))")
        }
    
        override func setValue(_ value: Any?, forUndefinedKey key: String) {
            print("\(key) \(String(describing: value))")
        }
    }
    let person = Person(dict: ["name": "zhouyu" ,"age": 28])

    5.Swift 4.0运行时获取类的属性列表

    import UIKit
    //@objcMembers Swift 4.0后,必须写,运行时才能获取属性
    @objcMembers class Person: NSObject {
        /// 姓名
        var name: String?
        /// 年龄
        var age: Int = 0
        /// 性别
        var sex: String?
    
        class func getClassPropertyList() -> [String] {
            var propertyList:[String] = []
            var count: UInt32 = 0
    
            //UnsafeMutablePointer<objc_property_t>?  数组
            let list = class_copyPropertyList(self, &count)
    
            for i in 0..<Int(count) {
                //objc_property_t
                guard let property = list?[i] else { continue }
                //UnsafePointer<Int8>   Int8-->Byte-->Char-->C语言的字符串
                let propertyCharName = property_getName(property)
                //C语言的字符串转Swift的String
                guard let propertyName = String(utf8String: propertyCharName)  else { continue }
                propertyList.append(propertyName)
            }
    
            free(list)
            return propertyList
        }
    }
    print(Person.getClassPropertyList())
    //结果
    ["name", "age", "sex"]

    1.基本数据类型,在OC中没有可选值这一说,如果定义成可选项,KVC获取不到,会崩溃
    2.private修饰的属性,运行时同样获取不到此属性,也会是KVC崩溃
    3.在Swift 4中继承 NSObject 的 swift class 不再默认全部 bridge 到 OC,如果想使用运行时获取类的细节,需要在class前面加上@objcMembers关键字。

    6.便利构造函数

    • convenience关键字修饰init(), 可以返回nil
    • 只有便利构造函数中可以调用self.init()
    • 便利构造函数不能被重写和super
    • 用于条件检测和简化对象创建
    • 常用与UIKit中,使用类工厂方法快速创建类似的控件
        convenience init?(name: String, age: Int, sex: String) {
            //书写判断条件
            if age <= 0 {
                return nil
            }
    
            //MARK: 调用self.init
            self.init()
    
            //给属性赋值
            self.name = name
            self.age = age
            self.sex = sex
        }
    展开全文
  • Swift基础 构造函数

    2017-11-29 14:01:42
    指定构造函数struct Person { init() { // 构造函数 } } class Person { init() { // 构造函数 } }如果在结构体中定义了属性,不用自己写构造函数,默认会有一个逐一成员构造函数。 如果在类中定义了属性(非...

    指定构造函数

    struct Person {
        init() {
            // 构造函数
        }
    }
    class Person {
        init() {
            // 构造函数
        }
    }

    如果在结构体中定义了属性,不用自己写构造函数,默认会有一个逐一成员构造函数。
    如果在类中定义了属性(非可选),自己就得在构造函数对属性进行初始化赋值,构造函数必须写。

    便利构造器

    在Swift中,多了一个便利构造器,即在init前面加上“convenience”

    struct Person {
        convenience init() {
            // 便利构造函数
            // 必须调用同类的指定构造函数(其中一个即可)
            self.init()
        }
    }
    class Person {
        convenience init() {
            // 便利构造函数
            // 必须调用同类的指定构造函数(其中一个即可)
            self.init()
        }
    }

    便利构造器有什么用呢,顾名思义嘛,就是为了便利。

    3个规则

    规则1: 指定构造器必须调用其直接父类的的指定构造器。
    规则2: 便利构造器必须调用同类中定义的其他构造器。
    规则3: 便利构造器必须最终导致一个指定构造器被调用。

    其实和容易记住

    指定构造器必须总是向上代理。
    便利构造器必须总是横向代理。

    2个阶段

    Swift的构造过程分2个阶段:

    阶段1:

    (1)构造器被调用
    (2)新实例分配内存,但内存还没初始化
    (3)指定构造器中,先对所在的类引入的属性(特有的属性)赋初始值。
    (4)指定构造器调用父类的构造器,对父类的属性赋初始值。
    (5)沿着构造链,一直往上执行,(父类可能还有父类,继续调用父类的构造器),直到构造链的顶端。
    (6)确保类所有属性(子类,父类所有的属性)都已经赋初始值,这就认为这个实例的内存已经完全初始化了,也就是可以使用了。阶段1完成。

    注意了,阶段1中,因为实例还没完成初始化,不能调用任何实例方法,不能读取任何实例的值,也不能引用self作为值使用。(可以使用self赋值,如 self.name = name)

    阶段2:

    (1)顶端构造器开始往下执行,每个构造器都有机会定制实例。当然,因为实例已经初始化了,可以调用方法,也可以修改属性值,也可以使用self。
    (2)最后,便利构造器也可以定制实例。

    class RootClass {
        var a: Int
        init(a: Int) {
            self.a = a            // (3) ------------ 阶段1
            apple()               // (4) ------------ 阶段2
        }
        func apple() {
            print("a apple")
        }
    }
    class SonClass: RootClass {
        var b: Int
        init(b: Int) {
            self.b = b            // (2) ------------ 阶段1
            super.init(a: 1)
            banana()              // (5) ------------ 阶段2
        }
        func banana() {
            print("b banana")
        }
    }
    class GrandsonClass: SonClass {
        var c: Int
        init(c: Int) {
            self.c = c            // (1) ------------ 阶段1
            super.init(b: 2)
            cat()                 // (6) ------------ 阶段2
        }
        func cat() {
            print("c cat")
        }
    }
    let c = GrandsonClass(c: 3)

    打印结果

    a apple
    b banana
    c cat

    两段式构造的优点:
    (1)防止属性值在初始化之前被访问
    (2)防止属性值被另一个构造器意外的赋值(??)

    4个安全检查

    为了保证两段式构造能顺利进行,编译器对代码进行4个安全检查

    安全检查1

    在调用父类的构造器前,要保证本类的属性全部赋初始值(这是初始化)。

    安全检查2

    必须先调用父类的构造器,然后再定制属性的值(这是定制),否则定制的属性值会被父类构造器覆盖。

    安全检查3

    便利构造器必须先调用同类的其他构造器,然后再定制属性的值(便利构造器定制属性值),否则定制的属性值会被同类的其他构造器覆盖。

    安全检查4

    在第1阶段没有完成前,不能调用实例的方法,不能读取属性值,不能引用self作为值使用。

    只要理解了两段式构造,自然就知道为什么会有这4个检查了,慢慢体会!!我也是晕了很久的,哈哈。

    指定构造器和便利构造器用途

    指定构造器主要用于初始化属性,给属性赋值。
    便利构造器主要方便外部函数调用,最后还是要调用指定构造器对属性进行初始化。

    只要认清这2点,应该知道用哪种构造器。

    构造器的自动继承

    如果子类的属性都有默认值,或者是可选的,并且没有定义任何的构造器,这个情况下,子类就会自动继承父类所有构造器。

    可失败构造函数

    如果构造函数传入的参数不符合需求,则可以返回nil

    class ITPerson {
        var name: String
        var sex: String
        init?(name: String, sex: String) {
            if sex != "male" {
                return nil
            }
            self.name = name
            self.sex = sex
        }
    }

    如果sex不是male的话,则返回nil,使用这种构造函数创建实例,这个实例的类型属于可选类型,ITPerson?

    var person = ITPerson(name: "johan", sex: "female") // person类型为ITPerson?
    person?.name

    必要构造器

    init前面加上“required”就是必要构造器了,表明该类的子类都要实现该构造器。

    class Person {
        required init() {
            // 必要构造函数
        }
    }
    展开全文
  • swift重载构造函数

    2018-07-25 10:27:11
    在使用swift重载构造函数的时候,需要注意。 // 1 构造函数的目的:给自己的属性分配空间并且设置初始值 // 2 调用父类构造函数之前,需要先给本类的属性设置初始值 // 3 调用父类的'构造函数',给父类的属性分配...

    在使用swift重载构造函数的时候,需要注意。

    // 1 构造函数的目的:给自己的属性分配空间并且设置初始值
    // 2 调用父类构造函数之前,需要先给本类的属性设置初始值
    // 3 调用父类的'构造函数',给父类的属性分配空间设置初始值NSObject没有属性,只有一个成员变量'isa'
    // 4 如果重载了构造函数,并且没有实现父类init方法,系统不再提供init()构造函数(默认是会有的) 因为默认的构造函数,不能给本类的属性分配空间
    展开全文
  • 结构体和类的实例在构造过程中会调用一种特殊的init方法,称为构造函数构造函数没有返回值,可以重载。在多个构造函数重载的情况下,运行环境可以根据它的外部参数名或参数列表调用合适的构造函数。默认构造函数...
  • Swift 2.0学习笔记(Day 37)——默认构造函数原创文章,欢迎转载。转载请注明:关东升的博客 结构体和类的实例在构造过程中会调用一种特殊的init方法,称为构造函数构造函数没有返回值,可以重载。在多个构造函数...
  • Swift 类的构造函数

    2019-08-06 01:44:00
    构造函数的介绍 构造函数类似于OC中的初始化方法:init方法 默认情况下载创建一个类时,必然会调用一个构造函数 即便是没有编写任何构造函数,编译器也会提供一个默认的构造函数。 如果是继承自NSObject,可以对...
  • 原创文章,欢迎转载。...向上代理发生在继承的情况下,在子类构造过程中,要先调用父类构造函数初始化父类的存储属性,这种构造函数称为指定构造函数。 构造函数调用规则Person和Student类示例: class Perso
  • 1.不用写标签的构造函数: 调用时不需要写标签: 2.需要写标签的构造函数 调用时: 默认只有初始化函数才可以修改变量的,其他函数不可以。如果想要修改的话必须在函数前加上mutating关键字:
  • Swift中,继承只能发生在类身上,结构体和枚举是不能够被继承的。一个类可以继承另一个类的方法、属性和下标。当一个类继承自另一个类时,这个类就被称之为子类,而被继承的类则被称之为父类(超类)。子类可以重写...
  • 关于便利构造函数,在实际开发中,可以对已有类的构造函数进行扩展,利用便利构造函数,简化对象的创建。
  • Swift构造函数可以多个,他们参数列表和返回值可以不同,这些构造函数构成重载。示例代码如下:class Rectangle { var width: Double var height: Double init(width: Double, height:
  • Swift构造函数 子类重写父类构造方法: 如果父类没有指定构造方法(带参数的构造方法), 子类重写父类构造方法就不需要调用super的构造方法, 反之亦然(如果父类有指定构造方法, 子类重写的构造方法中必须显示调用父类...
  • Swift构造函数为什么需要设计指定构造函数,便利构造函数构造函数的继承,这些概念?而且Swift很看重中几个概念,还有专门的关键字override和convenience来修饰,这种设计有什么好处?能处理什么问题?和Java中...
  • 这里先给出两个类,一个是Person类,一个是Student类import Foundation class Person { var name:String var weight:Double var height:Double //构造函数 init(name:String) { self.name = name...
  • swift 构造函数

    2016-08-07 00:30:59
    构造函数 : 分配内存空间 设置初始值 () 在swift中 所有的构造方法 都是init*/ import UIKitclass Person: NSObject { var name: String var age: Int //表示重写 表示重写父类的构造函数 //父类已经提供函数 ...
  • 便利构造函数: convenience 便利构造函数是对构造函数的一种功能扩充, 可以在初始化之前,根据指定的条件完成相关的初始化工作. class AClass { let numA: Int init(num: Int) { numA = num } //便利构造 //...
  • Swift开发中构造函数几点说明 一、Swift支持overload重载 二、构造函数 带有override前缀的init都是重写继承了父类的构造函数 class Person: NSObject { override init() { super.init() } } ...
  • ViewController.swift import UIKit /* 在swift中 所有的类和类的方法 都是共享的 在同一个命名空间 所有的类都是共享的 命名空间 是项目名称 */ class ViewController: UIViewController { override func ...
1 2 3 4 5 ... 20
收藏数 7,636
精华内容 3,054
关键字:

swift构造函数 构造过程