标签：str nts min param origin 检查 mys 划线 状态
苹果官方文档 Initialization
苹果文档中文翻译 初始化
类、结构体、枚举，准备实例的过程，叫初始化。这个过程需要，初始化器，来保证新的实例在第一次使用时，正确初始化。
创建实例时，必须为储存属性设置一个初始值，或分配一个默认的属性值。
创建特定类型的实例时，调用初始化器。使用 init 关键字。
init() {
// perform some initialization here
}struct Fahrenheit {
var temperature: Double
init() {
temperature = 32.0
}
}
var f = Fahrenheit()
print("The default temperature is \(f.temperature)° Fahrenheit")
// prints "The temperature is 32.0° Fahrenheit"上边的例子简写为：
struct Fahrenheit {
var temperature = 32.0
}输入形参和可选类型，来自定义初始化过程，或初始化时，分配常量属性。
struct Celsius {
var temperatureInCelsius: Double
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初始化器的参数名称和类型，区别初始化器时非常重要。没有时，Swift自动提供。
struct Color {
let red, green, blue: Double
init(red: Double, green: Double, blue: Double) {
self.red = red
self.green = green
self.blue = blue
}
init(white: Double) {
red = white
green = white
blue = white
}
}
let magenta = Color(red: 1.0, green: 0.0, blue: 1.0)
let halfGray = Color(white: 0.5)
let veryGreen = Color(0.0, 1.0, 0.0)
// this reports a compile-time error - external names are required不想写实际参数标签，可以用下划线 _ 替代。
struct Celsius {
var temperatureInCelsius: Double
init(fromFahrenheit fahrenheit: Double) {
temperatureInCelsius = (fahrenheit - 32.0) / 1.8
}
init(fromKelvin kelvin: Double) {
temperatureInCelsius = kelvin - 273.15
}
init(_ celsius: Double) {
temperatureInCelsius = celsius
}
}
let bodyTemperature = Celsius(37.0)
// bodyTemperature.temperatureInCelsius is 37.0可选类型属性，自动初始化为 nil，表示，初始化时故意设为“还没有值”。
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()
// prints "Do you like cheese?"
cheeseQuestion.response = "Yes, I do like cheese."初始化中，给常量属性赋值，保证在初始化结束时，有确定值。
对实例而言，初始化中，只能通过引用的类修改常量属性，不能被子类修改。
class SurveyQuestion {
let text: String
var response: String?
init(text: String) {
self.text = text
}
func ask() {
print(text)
}
}
let beetsQuestion = SurveyQuestion(text: "How about beets?")
beetsQuestion.ask()
// prints "How about beets?"
beetsQuestion.response = "I also like beets. (But not with cheese.)"没有提供初始化器，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)初始化器调用其他初始化器来执行部分实例的初始化，即初始化器委托。
值类型中，写自身自定的初始化器时，用 self.init 从相同值类型里引用其他初始化器。而且只能在初始化器里使用。
把自定义初始化器写在扩展里，让自定义值类型使用默认初始化器初始化、成员初始化器初始化、自定义初始化器初始化。
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)
let centerRect = Rect(center: Point(x: 4.0, y: 4.0),
size: Size(width: 3.0, height: 3.0))
// centerRect‘s origin is (2.5, 2.5) and its size is (3.0, 3.0)Swift 为类类型定义了两种初始化器以确保所有的存储属性接收一个初始值。
指定初始化器是类的主要初始化器，初始化所有类引用属性和调用父类初始化器。通常一个类只有一个。
便捷初始化器是次要初始化器，为一个类支持初始化器。
指定初始化器：
init(parameters) {
statements
}便捷初始化器，用 convenience修饰符：
convenience init(parameters) {
statements
}简单记忆，规则如下：
详细查阅文档。
第一阶段，存储属性引入类，分配初始值，初始状态确定。
第二阶段，在新实例使用之前定制它的存储属性。
具体解释，及安全检查，详见文档
子类初始化器匹配父类指定初始化器的时候，可以重写，使用 override 修饰符。匹配父类便捷初始化器的时候，不用写。
class Vehicle {
var numberOfWheels = 0
var description: String {
return "\(numberOfWheels) wheel(s)"
}
}
let vehicle = Vehicle()
print("Vehicle: \(vehicle。description)")
// Vehicle: 0 wheel(s)
class Bicycle: Vehicle {
override init() {
super.init()
numberOfWheels = 2
}
}
let bicycle = Bicycle()
print("Bicycle: \(bicycle.description)")
// Bicycle: 2 wheel(s)子类不能修改继承过来的常量属性。
如果子类引入的新属性都有默认值，
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)
}
override 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)"
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)
}
// 1 x Orange juice ?
// 1 x Bacon ?
// 6 x Eggs ?定义一个可失败的初始化器，在 init 关键字后添加问号 ？
struct Animal {
let species: String
init?(species: String) {
if species.isEmpty { return nil }
self.species = species
}
}
let someCreature = Animal(species: "Giraffe")
// someCreature is of type Animal?, not Animal
if let giraffe = someCreature {
print("An animal was initialized with a species of \(giraffe.species)")
}
// prints "An animal was initialized with a species of Giraffe"
let anonymousCreature = Animal(species: "")
// anonymousCreature is of type Animal?, not Animal
if anonymousCreature == nil {
print("The anonymous creature could not be initialized")
}
// prints "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.")
}
// prints "This is a defined temperature unit, so initialization succeeded."
let unknownUnit = TemperatureUnit(symbol: "X")
if unknownUnit == nil {
print("This is not a defined temperature unit, so initialization failed.")
}
// prints "This is not a defined temperature unit, so initialization failed."带有原始值的枚举会自动获得一个可失败初始化器
enum TemperatureUnit: Character {
case Kelvin = "K", Celsius = "C", Fahrenheit = "F"
}
let fahrenheitUnit = TemperatureUnit(rawValue: "F")
if fahrenheitUnit != nil {
print("This is a defined temperature unit, so initialization succeeded.")
}
// prints "This is a defined temperature unit, so initialization succeeded."
let unknownUnit = TemperatureUnit(rawValue: "X")
if unknownUnit == nil {
print("This is not a defined temperature unit, so initialization failed.")
}
// prints "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 CartItem: Product {
let quantity: Int
init?(name: String, quantity: Int) {
if quantity < 1 { return nil }
self.quantity = quantity
super.init(name: name)
}
}
if let twoSocks = CartItem(name: "sock", quantity: 2) {
print("Item: \(twoSocks.name), quantity: \(twoSocks.quantity)")
}
// prints "Item: sock, quantity: 2"
if let zeroShirts = CartItem(name: "shirt", quantity: 0) {
print("Item: \(zeroShirts.name), quantity: \(zeroShirts.quantity)")
} else {
print("Unable to initialize zero shirts")
}
// prints "Unable to initialize zero shirts"用子类的非可失败初始化器重写父类可失败初始化器，向上委托到父类初始化器的唯一办法是，强制展开父类可失败初始化器的结果。
class Document {
var name: String?
// this initializer creates a document with a nil name value
init() {}
// this initializer creates a document with a non-empty name value
init?(name: String) {
self.name = name
if name.isEmpty { return nil }
}
}
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
}
}
}
class UntitledDocument: Document {
override init() {
super.init(name: "[Untitled]")!
}
}可以使用可失败初始化器创建一个隐式展开具有合适类型的可选项实例。
在 init 后面添加惊叹号( init! ) 可以与 init？ 或init 互相委托调用。
初始化器前 添加 required 修饰符，所有该类子类必须实现该初始化器。
class SomeClass {
required init() {
// initializer implementation goes here
}
}子类重写父类必要初始化器时，必须同样添加 required 修饰符。
class SomeSubclass: SomeClass {
required init() {
// subclass implementation of the required initializer goes here
}
}当这个属性归属的实例初始化时，闭包或函数就会被调用，并且它的返回值就会作为属性的默认值。
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
}()
}注意结尾没有参数的圆括号，为立即执行闭包。闭包内不能读取其他属性值，也不能使用隐式self属性，或调用实例方法。
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(row: 0, column: 1))
// Prints "true"
print(board.squareIsBlackAt(row: 7, column: 7))
// Prints "false"标签：str nts min param origin 检查 mys 划线 状态
原文地址：https://www.cnblogs.com/ccjoy/p/8799075.html
