swift学习笔记之构造方法和析构方法

原创 2016年05月30日 10:58:13
//swift的构造器(Initilizer)和析构器(Deinitializer)
//构造器并不像函数和方法那样在括号前有一个可辨别的名字。所以在调用构造器时,主要通过构造器中的参数名和类型来确定需要调用的构造器。 正因为参数如此重要,如果你在定义构造器时没有提供参数的外部名字,Swift 会为每个构造器的参数自动生成一个跟内部名字相同的外部名,就相当于在每个构造参数之前加了一个哈希符号。

import Foundation

//默认构造器 init()
struct Fahrenheit {

    var temperature:Double
    init() {
    temperature = 32.0
    }

}
var f = Fahrenheit() //调用默认构造器,没有参数,没有返回值
print("the default temperature=\(f.temperature)")


//逐一成员构造器---只针对结构体..类没有该构造器
//如果结构体对所有存储型属性提供了默认值且自身没有提供定制的构造器,它们能自动获得一个逐一成员构造器。

struct Size {
    var width = 0.0, height = 0.0
}
let twoByTwo = Size(width: 2.0, height: 2.0)

struct Point {
    var x = 0.0 ,y = 0.0
}


//Swift 将为所有属性已提供默认值的且自身没有定义任何构造器的结构体或基类,提供一个默认的构造器

class ShoppingListItem {
    var name: String?
    var quantity = 1
    var purchased = false
}
var item = ShoppingListItem()//默认构造器




//自定义构造器 init(fromFahrenheit:)  和init(fromKelvin:)
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

//只要在构造过程结束前常量的值能确定,你可以在构造过程中的任意时间点修改常量属性的值。 对某个类实例来说,它的常量属性只能在定义它的类的构造过程中修改;不能在子类中修改。

class SurveyQuestion {
    let text: String //常量值,但不能初始化一个具体的值,可以是可选值
    var response: String?
    init(text: String) {
        self.text = text
    }
    func ask() {
        print(text)
    }
}
var a  = SurveyQuestion(text: "dddd")
a.ask();



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

//构造器可以通过调用其它构造器来完成实例的部分构造过程。这一过程称为构造器代理,它能减少多个构造器间的代码重复。 就是嵌套构造器方法 对于值类型,你可以使用self.init在自定义的构造器中引用其它的属于相同值类型的构造器。并且你只能在构造器内部调用self.init。

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

//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 override 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 ShpingListItem: RecipeIngredient {
    var purchased = false
    var description: String {
        var output = "\(quantity) x \(name.lowercaseString)"
        output += purchased ? " ✔" : " ✘"
        return output
    }
}

var breakfastList = [
    ShoppingListItem(),
    ShpingListItem(name: "Bacon"),
    ShpingListItem(name: "Eggs", quantity: 6),
]
//breakfastList[0].name = "Orange juice"  breakfastList[0]只读
//breakfastList[0].purchased = true
for item in breakfastList {
    print(item.description)
}
// 1 x orange juice ✔
// 1 x bacon ✘
// 6 x eggs ✘

//与方法、属性和下标不同,在重载构造器时你没有必要使用关键字override。

//如果你重载的构造器是一个指定构造器,你可以在子类里重载它的实现,并在自定义版本的构造器中调用父类版本的构造器。 如果你重载的构造器是一个便利构造器,你的重载过程必须通过调用同一类中提供的其它指定构造器来实现。
//
//自动构造器的继承
//
//如果子类没有定义任何指定构造器,它将自动继承所有父类的指定构造器。
//如果子类提供了所有父类指定构造器的实现--不管是通过规则1继承过来的,还是通过自定义实现的--它将自动继承所有父类的便利构造器






//通过闭包和函数来设置属性的默认值
//
//这种类型的闭包或函数一般会创建一个跟属性类型相同的临时变量,然后修改它的值以满足预期的初始状态,最后将这个临时变量的值作为属性的默认值进行返回。 注意闭包结尾的大括号后面接了一对空的小括号。这是用来告诉 Swift 需要立刻执行此闭包。如果你忽略了这对括号,相当于是将闭包本身作为值赋值给了属性,而不是将闭包的返回值赋值给属性。 如果你使用闭包来初始化属性的值,请记住在闭包执行时,实例的其它部分都还没有初始化。这意味着你不能够在闭包里访问其它的属性,就算这个属性有默认值也不允许。同样,你也不能使用隐式的self属性,或者调用其它的实例方法。 每当一个新的实例创建时,对应的赋值闭包会执行,

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]
    }
}


//析构器,析构器和构造器正好相反,在对象释放的时候调用,使用关键字deinit
class Player {
    var coinsInPurse:Int
    init(coins: Int) {
        print("call init")
        coinsInPurse = coins
    }
    func winCoins(coins: Int) {
        coinsInPurse += 10
    }
    deinit {
        coinsInPurse = 0
    }
}
var playerOne: Player? = Player(coins: 100)
print("coinsInPurse   :  \(playerOne!.coinsInPurse) coins")


    playerOne = nil //调用deinit
    print("PlayerOne has left the game")


版权声明:版权所有,不得转载

相关文章推荐

swift自学笔记(六)(构造方法、析构方法)

// ****************构造方法*****************************// //是一种特殊的方法,一个对象创建完后都需要调用构造方法进行初始化(比如属性初始化)...

学习PHP面向对象(二)构造方法与析构方法

大多数类都有一种称为构造函数的特殊方法。当创建一个对象时,它将自动调用构造函数,也就是使用new这个关键字来实例化对象的时候自动调用构造方法。 构造函数的声明与其它操作的声明一样,只是其名称必须...

swift学习笔记(13)- 构造过程、析构过程

构造过程是使用类、结构体或枚举类型的实例之前的准备过程。在新实例可用前必须执行这个过程,具体操作包括设置实例中每个存储型属性的初始值和执行其他必须的设置或初始化工作。通过定义构造器来实现构造过程,这些...

Java 构造方法学习笔记

class PoolPuzzleOne{ public static void main(String [] args){ int x = 0; while(x...

php面向对象(一),类,类成员,构造方法,析构方法及对象的销毁

示例代码(先看个大概)<?php class Person{ const MAX_AGE = 130; // 类常量:假设人的最长年龄为130 var $nam...
  • ydxlt
  • ydxlt
  • 2016-01-29 12:10
  • 2298

构造方法与析构方法、对象类型在内存中的分配

构造方法在每个声明类中都要一个称为构造方法的特殊方法,如果没有显示的声明它,类中会默认存在一个没有参数列表并且内容为空的构造方法。如果显示的声明它,则类中默认的构造方法不存在。当创建一个对象时,构造方...

java学习笔记之String 构造方法

// string 的都构造 String() String str = new String(); // string 的都构造 String(byte[] bytes) byte[]...

20150902 Java学习笔记-构造方法,关键字,封装性

1. 构造方法构造方法的作用:在对象实例化的时候为类之中的属性进行初始化操作. 类之中编写构造方法后的结构要进行一些说明: 类之中会存在属性,构造方法,普通方法,所以一定要先写属性,随后写构造方法...

java学习笔记-构造方法总结

构造方法和实例方法的区别 一、主要的区别在于三个方面:修饰符、返回值、命名 1、和实例方法一样,构造器可以有任何访问的修饰符,public、private、protected或者没有修饰符 ,...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)