初始化函数
import UIKit
// 初始化函数
struct Fahrenheit {
var temperature: Double
init () {
temperature = 32.0
}
}
var f = Fahrenheit()
print("The default temperature is \(f.temperature)° Fahrenheit")
struct Celsius {
var temperatureInCelsius: Double
init(fromFahrenheit fahrenheit: Double) {
temperatureInCelsius = (fahrenheit - 32.0) / 1.8
}
init(fromKelvin kelvin: Double) {
temperatureInCelsius = kelvin - 273.15
}
init(celisus: Double) {
temperatureInCelsius = celisus
}
}
let boilingPointOfWater = Celsius(fromFahrenheit: 212.0)
print("boilingPointOfWater temperatureInCelsius value is \(boilingPointOfWater.temperatureInCelsius)")
let freezingPointOfWater = Celsius(fromKelvin: 273.15)
print("freezingPointOfWater temperatureInCelsius value is \(freezingPointOfWater.temperatureInCelsius)")
let bodyTemperature = Celsius(celisus: 37.0)
print("bodyTemperature temperatureInCelsius value is \(bodyTemperature.temperatureInCelsius)")
// 可选属性
class SurveyQuestion {
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()
cheeseQuestion.response = "Yes, I do like cheese."
// 初始化时赋值常量属性
class AnotherSurveyQuestion {
let text: String
var response: String?
init(text: String) {
self.text = text
}
func ask() {
print(text)
}
}
let anotherCheeseQuestion = AnotherSurveyQuestion(text: "Do you like cheese?")
// 值类型的初始化
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.0)
let originY = center.y - (size.height / 2.0)
self.init(origin: Point(x: originX, y: originY), size: size)
}
}
let basicRect = Rect()
let originRect = Rect(origin: Point(x: 2.0, y: 2.0), size: Size(width: 5.0, height: 5.0))
let centerRect = Rect(center: Point(x: 4.0, y: 4.0), size: Size(width: 3.0, height: 3.0))
print("basicRect's origin is (\(basicRect.origin.x), \(basicRect.origin.y)) and its size is (\(basicRect.size.width), \(basicRect.size.height))")
print("originRect origin is (\(originRect.origin.x), \(originRect.origin.y)) and its size is (\(originRect.size.width), \(originRect.size.height))")
print("centerRect origin is (\(centerRect.origin.x), \(centerRect.origin.y)) and its size is (\(centerRect.size.width), \(centerRect.size.height))")
console log 如下
初始化函数.png
类的指定初始化函数和便利初始化函数
// 类的指定初始化函数和便利初始化函数
class Food {
var name: String
init(name: String) {
self.name = name
}
convenience init()
{
self.init(name: "[Unnamed]")
}
}
let nameMeat = Food(name: "Bacon")
print("nameMeat's name is \(nameMeat.name)")
let mysteryMeat = Food()
print("mysteryMeat's name is \(mysteryMeat.name)")
class RecipeIngredient: Food {
var quantity: Int
init(name: String, quantity: Int) {
self.quantity = quantity
super.init(name: name)
}
override convenience init(name: String) {
self.init(name: name, quantity: 1)
}
}
let oneMysteryItem = RecipeIngredient()
print("oneMysteryItem's name is \(oneMysteryItem.name) and quantity is \(oneMysteryItem.quantity)")
let oneBacon = RecipeIngredient(name: "Bacon")
print("oneBacon's name is \(oneBacon.name) and quantity is \(oneBacon.quantity)")
let sixEggs = RecipeIngredient(name: "Eggs", quantity: 6)
print("sixEggs's name is \(sixEggs.name) and quantity is \(sixEggs.quantity)")
class ShoppingListItem: RecipeIngredient {
var purchased = false
var description: String {
var output = "\(quantity) x \(name)"
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 {
print(item.description)
}
console log 如下
类的指定初始化函数和便利初始化函数.png
注意: 子类指定初始化函数必须调用直接父类的指定初始化函数，便利初始化函数要最终调用指定初始化函数
RecipeIngredient子类与Food父类 分析
RecipeIngredient子类与Food父类.png
可失败的初始化函数
// 结构体 可失败的初始化函数
struct Animal {
let species: String
init?(species: String) {
if species.isEmpty {
return nil
}
self.species = species
}
}
let someCreature = Animal(species: "Giraffe")
if let giraffe = someCreature {
print("An animal was initialized with a species of \(giraffe.species)")
}
let anonymousCreature = Animal(species: "")
if anonymousCreature == nil {
print("The anonymous creature could not be initialized")
}
// 枚举 可失败的初始化函数
enum TemperatureUnit {
case kelvin, celsius, fahrenheit
init?(symbol: Character) {
switch symbol {
case "K":
self = .kelvin
case "C":
self = .celsius
case "F":
self = .fahrenheit
default:
return nil
}
}
}
let fahrenheitUnit = TemperatureUnit(symbol: "F")
if fahrenheitUnit != nil {
print("This is a defined temperature unit, so initialization succeeded.")
}
let unkownUnit = TemperatureUnit(symbol: "X")
if unkownUnit == nil {
print("This is not a defined temperature unit, so initialization failed.")
}
// 枚举值raw value 可失败的初始化函数
enum AnotherTemperatureUnit: Character {
case kelvin = "K", celisus = "C", fahrenheit = "F"
}
let anotherFahrenheitUnit = AnotherTemperatureUnit(rawValue: "F")
if anotherFahrenheitUnit != nil {
print("This is a defined temperature unit, so initialization succeeded.")
}
let anotherUnkownUnit = AnotherTemperatureUnit(rawValue: "X")
if anotherUnkownUnit == nil {
print("This is not a defined temperature unit, so initialization failed.")
}
// 类的可失败初始化函数
class Product {
let name: String
init?(name: String)
{
if name.isEmpty {
return nil
}
self.name = name
}
}
class CarItem: Product {
let quantity: Int
init?(name: String, quantity: Int) {
if quantity < 1 {
return nil
}
self.quantity = quantity
super.init(name: name)
}
}
if let twoSocks = CarItem(name: "sock", quantity: 2) {
print("Item: \(twoSocks.name), quantity: \(twoSocks.quantity)")
}
if let zeroShirts = CarItem(name: "shirt", quantity: 0) {
print("Item: \(zeroShirts.name), quantity: \(zeroShirts.quantity)")
} else {
print("Unable to initialize zero shirts")
}
if let oneUnnamed = CarItem(name: "", quantity: 1) {
print("Item: \(oneUnnamed.name), quantity: \(oneUnnamed.quantity)")
} else {
print("Unable to initialize one unnamed product")
}
// 子类重写可失败的初始化函数
class Document {
var name: String?
init () {
}
init?(name: String) {
if name.isEmpty {
return nil
}
self.name = name
}
}
class AutomaticallyNamedDocument: Document {
override init(){
super.init()
self.name = "Untitled"
}
override init(name: String) {
super.init()
if name.isEmpty {
self.name = "Untitled"
} else {
self.name = name
}
}
}
let oneDocument = AutomaticallyNamedDocument(name: "")
print(oneDocument.name!)
console log 如下
可失败的初始化函数.png
通过闭包或者函数设置属性值
// 通过闭包或者函数设置属性值
struct Chessboard {
let boardColors: [Bool] = {
var temporaryBoard = [Bool]()
var isBlack = false
for i in 1...8 {
for j in 1...8 {
temporaryBoard.append(isBlack)
isBlack = !isBlack
}
isBlack = !isBlack
}
return temporaryBoard
}()
func squareIsBlackAt(row: Int, column: Int) -> Bool {
return boardColors[(row * 8) + column]
}
}
let board = Chessboard()
print(board.squareIsBlackAt(0, column: 1))
print(board.squareIsBlackAt(7, column: 7))
console log 如下
通过闭包或者函数设置属性值.png
