Initialization


Initialization is the process of preparing an instance of a class, structure, or enumeration for use. This process involves setting an initial value for each stored property on that instance and performing any other setup or initialization that is required before the new instance is ready for use.

Unlike Objective-C initializers, Swift initializers do not return a value. 

Instances of class types can also implement a deinitializer, which performs any custom cleanup just before an instance of that class is deallocated. For more information about deinitializers, see Deinitialization.

Setting Initial Values for Stored Properties

Classes and structures must set all of their stored properties to an appropriate initial value by the time an instance of that class or structure is created. Stored properties cannot be left in an indeterminate state.

You can set an initial value for a stored property within an initializer, or by assigning a default property value as part of the property’s definition. These actions are described in the following sections.

NOTE

When you assign a default value to a stored property, or set its initial value within an initializer, the value of that property is set directly, without calling any property observers.(initialization작업에서는 property observer가 작동하지 않는다고 이해 하였다.)

Initializers

Initializers are called to create a new instance of a particular type.written using the init keyword:

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 default temperature is 32.0° Fahrenheit”

Default Property Values

If a property always takes the same initial value, provide a default value rather than setting a value within an initializer. The end result is the same, but the default value ties the property’s initialization more closely to its declaration. 

struct Fahrenheit {
   var temperature = 32.0
}

Customizing Initialization

Initialization Parameters

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

.

Parameter Names and Argument Labels

As with function and method parameters, initialization parameters can have both a parameter name for use within the initializer’s body and an argument label for use when calling the initializer.

Swift provides an automatic argument label for every parameter in an initializer if you don’t provide one.

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 – argument labels are required

Initializer Parameters Without Argument Labels

If you do not want to use an argument label for an initializer parameter, write an underscore (_) instead of an explicit argument label for that parameter to override the default behavior.

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

Optional Property Types

If your custom type has a stored property that is logically allowed to have “no value”—perhaps because its value cannot be set during initialization, or because it is allowed to have “no value” at some later point—declare the property with an optional type. Properties of optional type are automatically initialized with a value of nil, indicating that the property is deliberately intended to have “no value yet” during initialization.

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.”

Assigning Constant Properties During Initialization

You can assign a value to a constant property at any point during initialization, as long as it is set to a definite value by the time initialization finishes. Once a constant property is assigned a value, it can’t be further modified.  (constant의 경우 initialization마무리 전까지는 값이 할당되어야 한다는 이야기 )

NOTE

For class instances, a constant property can be modified during initialization only by the class that introduces it. It cannot be modified by a subclass.

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.)”

Default Initializers

Swift provides a default initializer for any structure or class that provides default values for all of its properties and does not provide at least one initializer itself. 

(class , structure 는 initializer를 통해 obj가 만들어진다. 즉 적어도 하나의 init()이 존재해야 한다는 이야기. 단 위의 내용같이 모든 property에 기본값이 주어지고 initilaizer가 하나도 없는 경우 swift가 스스로 하나의 init() 즉 default initializer를 만든다는 이야기)

(모든 property들에 기본값이 주어지고 initializer가 하나도없는 경우 swift 자체에서 default initializer가 제공되어서 스스로 init작업이 이루어 진다는 이야기.)

(바로 밑에서 확인할수 있듯이 structure는 default initializer뿐만아니라

Memberwise Initializers 도 기본으로 제공한다.)

class ShoppingListItem {
   var name: String?
   var quantity = 1
   var purchased = false
}
var item = ShoppingListItem()

Memberwise Initializers for Structure Types

Structure types automatically receive a memberwise initializer if they do not define any of their own custom initializers. (특별히 initializer를 작성하지 않더라도 기본적으로  property 이름을 parameter name으로 하는 기본 initializer가 제공된다는 이야기)

The memberwise initializer is a shorthand way to initialize the member properties of new structure instances. Initial values for the properties of the new instance can be passed to the memberwise initializer by name.

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

Initializer Delegation for Value Types

Initializers can call other initializers to perform part of an instance’s initialization. This process, known as initializer delegation, avoids duplicating code across multiple initializers. (initilizer가 initializer를 호출하는 방법 설명)

The rules for how initializer delegation works, and for what forms of delegation are allowed, are different for value types and class types. Value types (structures and enumerations) do not support inheritance, and so their initializer delegation process is relatively simple, because they can only delegate to another initializer that they provide themselves. Classes, however, can inherit from other classes, as described in Inheritance. This means that classes have additional responsibilities for ensuring that all stored properties they inherit are assigned a suitable value during initialization. These responsibilities are described in Class Inheritance and Initialization below.

For value types, you use self.init to refer to other initializers from the same value type when writing your own custom initializers. You can call self.init only from within an initializer.

Note that if you define a custom initializer for a value type, you will no longer have access to the default initializer (or the memberwise initializer, if it is a structure) for that type. This constraint prevents a situation in which additional essential setup provided in a more complex initializer is accidentally circumvented by someone using one of the automatic initializers.

NOTE

If you want your custom value type to be initializable with the default initializer and memberwise initializer, and also with your own custom initializers, write your custom initializers in an extension rather than as part of the value type’s original implementation. For more information, see Extensions.

struct Size {
   var width = 0.0, height = 0.0
}
struct Point {
   var x = 0.0, y = 0.0
}

You can initialize the Rect structure below in one of three ways

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)

// Rect()의 경우 개발자에 의해 initializer가 제공되었으므로 default initializer는 자동으로제공되지 않는다. 그래서  empty init()을 만들었고 Rect structure의 모든 property들은 기본값들이 할당되어있으므로 obj생성에 문제가 없다. 

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)

Class Inheritance and Initialization

참조 : http://www.codingexplorer.com/designated-initializers-convenience-initializers-swift/

참조 : tumblr #class #initializer #initialization

All of a class’s stored properties—including any properties the class inherits from its superclass—must be assigned an initial value during initialization.

Swift defines two kinds of initializers for class types to help ensure all stored properties receive an initial value. These are known as designated initializers and convenience initializers.

Designated Initializers and Convenience Initializers

Designated initializers are the primary initializers for a class. A designated initializer fully initializes all properties introduced by that class and calls an appropriate superclass initializer to continue the initialization process up the superclass chain.

Classes tend to have very few designated initializers, and it is quite common for a class to have only one. Designated initializers are “funnel” points through which initialization takes place, and through which the initialization process continues up the superclass chain.

Every class must have at least one designated initializer. In some cases, this requirement is satisfied by inheriting one or more designated initializers from a superclass, as described in Automatic Initializer Inheritance below.

Convenience initializers are secondary, supporting initializers for a class. You can define a convenience initializer to call a designated initializer from the same class as the convenience initializer with some of the designated initializer’s parameters set to default values. You can also define a convenience initializer to create an instance of that class for a specific use case or input value type.

You do not have to provide convenience initializers if your class does not require them. Create convenience initializers whenever a shortcut to a common initialization pattern will save time or make initialization of the class clearer in intent.

Syntax for Designated and Convenience Initializers

Designated initializers

init(parameters) {
   statements
}

Convenience initializers 

convenience init(parameters) {
   statements
}

Initializer Delegation for Class Types

To simplify the relationships between designated and convenience initializers, Swift applies the following three rules for delegation calls between initializers:

  • Rule 1

A designated initializer must call a designated initializer from its immediate superclass.

  • Rule 2

A convenience initializer must call another initializer from the same class.

  • Rule 3

A convenience initializer must ultimately call a designated initializer.

A simple way to remember this is:

  • Designated initializers must always delegate up.
  • Convenience initializers must always delegate across.
image

Two-Phase Initialization

Class initialization in Swift is a two-phase process. In the first phase, each stored property is assigned an initial value by the class that introduced it. Once the initial state for every stored property has been determined, the second phase begins, and each class is given the opportunity to customize its stored properties further before the new instance is considered ready for use.

NOTE

Swift’s two-phase initialization process is similar to initialization in Objective-C. The main difference is that during phase 1, Objective-C assigns zero or null values (such as 0 or nil) to every property. Swift’s initialization flow is more flexible in that it lets you set custom initial values, and can cope with types for which 0 or nil is not a valid default value.

Swift’s compiler performs four helpful safety-checks to make sure that two-phase initialization is completed without error:

Safety check 1

A designated initializer must ensure that all of the properties introduced by its class are initialized before it delegates up to a superclass initializer.

As mentioned above, the memory for an object is only considered fully initialized once the initial state of all of its stored properties is known. In order for this rule to be satisfied, a designated initializer must make sure that all of its own properties are initialized before it hands off up the chain.

Safety check 2

A designated initializer must delegate up to a superclass initializer before assigning a value to an inherited property. If it doesn’t, the new value the designated initializer assigns will be overwritten by the superclass as part of its own initialization. (상속된것이 아닌 class자체의 property는 그 class initializer에서 initialization되고 난후 superclass로 이동한다.)

Safety check 3

A convenience initializer must delegate to another initializer before assigning a value to any property (including properties defined by the same class). If it doesn’t, the new value the convenience initializer assigns will be overwritten by its own class’s designated initializer.

Safety check 4

An initializer cannot call any instance methods, read the values of any instance properties, or refer to selfas a value until after the first phase of initialization is complete.

The class instance is not fully valid until the first phase ends. 

Properties can only be accessed, and methods can only be called, once the class instance is known to be valid at the end of the first phase.

(그렇기 때문에 첫 phase가 끝나기 전에 함수 작업이 필요한 경우 closure를 이요하는것 으로 추측)

Here’s how two-phase initialization plays out, based on the four safety checks above:

Phase 1

  • A designated or convenience initializer is called on a class.
  • Memory for a new instance of that class is allocated. The memory is not yet initialized.
  • A designated initializer for that class confirms that all stored properties introduced by that class have a value. The memory for these stored properties is now initialized.
  • The designated initializer hands off to a superclass initializer to perform the same task for its own stored properties.

    (subclass에서 superclass initializer를 호출하게 되면 그 위로 올라 가서 subclass에서 했던작업과 같은 작업을 수행한다는 이야기)

  • This continues up the class inheritance chain until the top of the chain is reached.
  • Once the top of the chain is reached, and the final class in the chain has ensured that all of its stored properties have a value, the instance’s memory is considered to be fully initialized, and phase 1 is complete.

Phase 2

  • Working back down from the top of the chain, each designated initializer in the chain has the option to customize the instance further. Initializers are now able to access self and can modify its properties, call its instance methods, and so on.
  • Finally, any convenience initializers in the chain have the option to customize the instance and to work with self.

Here’s how phase 1 looks for an initialization call for a hypothetical subclass and superclass:

image

In this example, initialization begins with a call to a convenience initializer on the subclass. This convenience initializer cannot yet modify any properties. It delegates across to a designated initializer from the same class.

The designated initializer makes sure that all of the subclass’s properties have a value, as per safety check 1. It then calls a designated initializer on its superclass to continue the initialization up the chain.

The superclass’s designated initializer makes sure that all of the superclass properties have a value. There are no further superclasses to initialize, and so no further delegation is needed.

As soon as all properties of the superclass have an initial value, its memory is considered fully initialized, and Phase 1 is complete.

Here’s how phase 2 looks for the same initialization call:

image

The superclass’s designated initializer now has an opportunity to customize the instance further (although it does not have to).

Once the superclass’s designated initializer is finished, the subclass’s designated initializer can perform additional customization (although again, it does not have to).

Finally, once the subclass’s designated initializer is finished, the convenience initializer that was originally called can perform additional customization.

Initializer Inheritance and Overriding

Unlike subclasses in Objective-C, Swift subclasses do not inherit their superclass initializers by default.(기본적으로 subclass는 supercalss initializer를 이용하지 않는다.) Swift’s approach prevents a situation in which a simple initializer from a superclass is inherited by a more specialized subclass(보통 subclass에서 superclass보다 많은 property를 사용하고 그러므로 보다 많은 property를 initial해야하기 때문) and is used to create a new instance of the subclass that is not fully or correctly initialized.

NOTE

Superclass initializers are inherited in certain circumstances, but only when it is safe and appropriate to do so. For more information, see Automatic Initializer Inheritance below.

(참고사항 https://theswiftdev.com/2017/10/10/swift-4-init-patterns/

For Swift classes you will only get an internal default initializer for free if you provide default values for all the stored properties, even for optional ones. In practice it looks something like this:

“)

If you want a custom subclass to present one or more of the same initializers as its superclass, you can provide a custom implementation of those initializers within the subclass.

When you write a subclass initializer that matches a superclass designated initializer, you are effectively providing an override of that designated initializer. Therefore, you must write the override modifier before the subclass’s initializer definition. This is true even if you are overriding an automatically provided default initializer, as described in Default Initializers.

(class 와 structure의 경우 모든 property의 기본값이 주어지는 경우 default initializer init() 가 제공된다. 또 structure의 경우 기본적으로 Memberwise Initializers 도 제공된다.)

As with an overridden property, method or subscript, the presence of the override modifier prompts Swift to check that the superclass has a matching designated initializer to be overridden, and validates that the parameters for your overriding initializer have been specified as intended.

NOTE

You always write the override modifier when overriding a superclass designated initializer, even if your subclass’s implementation of the initializer is a convenience initializer.

Conversely, if you write a subclass initializer that matches a superclass convenience initializer, that superclass convenience initializer can never be called directly by your subclass, as per the rules described above in Initializer Delegation for Class Types. Therefore, your subclass is not (strictly speaking) providing an override of the superclass initializer. As a result, you do not write the override modifier when providing a matching implementation of a superclass convenience initializer. (하부 subclass에서 superclass의 convenience initializer를 override하는 경우는 override modifier를 사용할 필요없음)

The example below defines a base class called Vehicle. This base class declares a stored property called numberOfWheels, with a default Int value of 0. The numberOfWheels property is used by a computed property called description to create a String description of the vehicle’s characteristics:

class Vehicle {
   var numberOfWheels = 0
   var description: String {
       return “(numberOfWheels) wheel(s)”
   }
}

let vehicle = Vehicle()
print(“Vehicle: (vehicle.description)”)
// Vehicle: 0 wheel(s)

The next example defines a subclass of Vehicle called Bicycle:

class Bicycle: Vehicle {
   override init() {
       super.init()
       numberOfWheels = 2
   }
}

The Bicycle subclass defines a custom designated initializer, init(). This designated initializer matches a designated initializer from the superclass of Bicycle, and so the Bicycle version of this initializer is marked with the override modifier.

The init() initializer for Bicycle starts by calling super.init(), which calls the default initializer for the Bicycle class’s superclass, Vehicle. This ensures that the numberOfWheels inherited property is initialized by Vehicle before Bicycle has the opportunity to modify the property. After calling super.init(), the original value of numberOfWheels is replaced with a new value of 2.

If you create an instance of Bicycle, you can call its inherited description computed property to see how its numberOfWheels property has been updated:

let bicycle = Bicycle()
print(“Bicycle: (bicycle.description)”)
// Bicycle: 2 wheel(s)

NOTE

Subclasses can modify inherited variable properties during initialization, but can not modify inherited constant properties.

Automatic Initializer Inheritance

As mentioned above, subclasses do not inherit their superclass initializers by default. However, superclass initializers are automatically inherited if certain conditions are met. In practice, this means that you do not need to write initializer overrides in many common scenarios, and can inherit your superclass initializers with minimal effort whenever it is safe to do so.

Assuming that you provide default values for any new properties you introduce in a subclass, the following two rules apply:

Rule 1

If your subclass doesn’t define any designated initializers, it automatically inherits all of its superclass designated initializers.

Rule 2

If your subclass provides an implementation of all of its superclass designated initializers—either by inheriting them as per rule 1, or by providing a custom implementation as part of its definition—then it automatically inherits all of the superclass convenience initializers.

These rules apply even if your subclass adds further convenience initializers.

NOTE

A subclass can implement a superclass designated initializer as a subclass convenience initializer as part of satisfying rule 2.

Designated and Convenience Initializers in Action

(class initializer 총정리 예시)

The following example shows designated initializers, convenience initializers, and automatic initializer inheritance in action. This example defines a hierarchy of three classes called Food, RecipeIngredient, and ShoppingListItem, and demonstrates how their initializers interact.

The base class in the hierarchy is called Food, which is a simple class to encapsulate the name of a foodstuff. The Food class introduces a single String property called name and provides two initializers for creating Food instances:

class Food {
   var name: String
   init(name: String) {
       self.name = name
   }
   convenience init() {
       self.init(name: “[Unnamed]”)
   }
}

The figure below shows the initializer chain for the Food class:

image

Classes do not have a default memberwise initializer, and so the Food class provides a designated initializer that takes a single argument called name. This initializer can be used to create a new Food instance with a specific name:

let namedMeat = Food(name: “Bacon”)
// namedMeat’s name is “Bacon”

The init(name: String) initializer from the Food class is provided as a designated initializer, because it ensures that all stored properties of a new Food instance are fully initialized. The Food class does not have a superclass, and so the init(name: String) initializer does not need to call super.init() to complete its initialization.

The Food class also provides a convenience initializer, init(), with no arguments. The init() initializer provides a default placeholder name for a new food by delegating across to the Food class’s init(name: String) with a name value of [Unnamed]:

let mysteryMeat = Food()
// mysteryMeat’s name is “[Unnamed]”

The second class in the hierarchy is a subclass of Food called RecipeIngredient. The RecipeIngredient class models an ingredient in a cooking recipe. It introduces an Int property called quantity (in addition to the name property it inherits from Food) and defines two initializers for creating RecipeIngredient instances:

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

The figure below shows the initializer chain for the RecipeIngredient class:

image

The RecipeIngredient class has a single designated initializer, init(name: String, quantity: Int), which can be used to populate all of the properties of a new RecipeIngredient instance. This initializer starts by assigning the passed quantity argument to the quantity property, which is the only new property introduced by RecipeIngredient. After doing so, the initializer delegates up to the init(name: String) initializer of the Food class. This process satisfies safety check 1 from Two-Phase Initialization above.

RecipeIngredient also defines a convenience initializer, init(name: String), which is used to create a RecipeIngredient instance by name alone. This convenience initializer assumes a quantity of 1 for any RecipeIngredient instance that is created without an explicit quantity. The definition of this convenience initializer makes RecipeIngredient instances quicker and more convenient to create, and avoids code duplication when creating several single-quantity RecipeIngredient instances. This convenience initializer simply delegates across to the class’s designated initializer, passing in a quantity value of 1.

The init(name: String) convenience initializer provided by RecipeIngredient takes the same parameters as the init(name: String) designated initializer from Food. Because this convenience initializer overrides a designated initializer from its superclass, it must be marked with the override modifier (as described in Initializer Inheritance and Overriding).

Even though RecipeIngredient provides the init(name: String) initializer as a convenience initializer, RecipeIngredient has nonetheless provided an implementation of all of its superclass’s designated initializers. Therefore, RecipeIngredient automatically inherits all of its superclass’s convenience initializers too.

In this example, the superclass for RecipeIngredient is Food, which has a single convenience initializer called init(). This initializer is therefore inherited by RecipeIngredient. The inherited version of init() functions in exactly the same way as the Food version, except that it delegates to the RecipeIngredient version of init(name: String) rather than the Food version. ( 즉 

RecipeIngredient 클래스의 override convenience init(name: String) 가 호출 된다는 이야기) 

All three of these initializers can be used to create new RecipeIngredient instances:

let oneMysteryItem = RecipeIngredient()
let oneBacon = RecipeIngredient(name: “Bacon”)
let sixEggs = RecipeIngredient(name: “Eggs”, quantity: 6)

The third and final class in the hierarchy is a subclass of RecipeIngredient called ShoppingListItem. The ShoppingListItem class models a recipe ingredient as it appears in a shopping list.

Every item in the shopping list starts out as “unpurchased”. To represent this fact, ShoppingListItemintroduces a Boolean property called purchased, with a default value of false. ShoppingListItem also adds a computed description property, which provides a textual description of a ShoppingListItem instance:

class ShoppingListItem: RecipeIngredient {
   var purchased = false
   var description: String {
       var output = “(quantity) x (name)”
       output += purchased ? “ ✔” : “ ✘”
       return output
   }
}

NOTE

ShoppingListItem does not define an initializer to provide an initial value for purchased, because items in a shopping list (as modeled here) always start out unpurchased.

Because it provides a default value for all of the properties it introduces and does not define any initializers itself, ShoppingListItem automatically inherits all of the designated and convenience initializers from its superclass.

The figure below shows the overall initializer chain for all three classes:

image

You can use all three of the inherited initializers to create a new ShoppingListItem instance:

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 ✘

Here, a new array called breakfastList is created from an array literal containing three new ShoppingListItem instances. The type of the array is inferred to be [ShoppingListItem]. After the array is created, the name of the ShoppingListItem at the start of the array is changed from "[Unnamed]" to "Orange juice" and it is marked as having been purchased. Printing the description of each item in the array shows that their default states have been set as expected.

Failable Initializers

It is sometimes useful to define a class, structure, or enumeration for which initialization can fail. This failure might be triggered by invalid initialization parameter values, the absence of a required external resource, or some other condition that prevents initialization from succeeding.

To cope with initialization conditions that can fail, define one or more failable initializers as part of a class, structure, or enumeration definition. You write a failable initializer by placing a question mark after the init keyword (init?).

A failable initializer creates an optional value of the type it initializes. You write return nil within a failable initializer to indicate a point at which initialization failure can be triggered.

NOTE

Strictly speaking, initializers do not return a value. Rather, their role is to ensure that self is fully and correctly initialized by the time that initialization ends. Although you write return nil to trigger an initialization failure, you do not use the return keyword to indicate initialization success.

struct Animal {
   let species: String
   init?(species: String) {
       if species.isEmpty { return nil }
       self.species = species
   }
}

You can use this failable initializer to try to initialize a new Animal instance and to check if initialization succeeded:

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”

If you pass an empty string value to the failable initializer’s species parameter, the initializer triggers an initialization failure:

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”

NOTE

Checking for an empty string value (such as "" rather than "Giraffe") is not the same as checking for nil to indicate the absence of an optional String value. In the example above, an empty string ("") is a valid, nonoptional String. However, it is not appropriate for an animal to have an empty string as the value of its species property. To model this restriction, the failable initializer triggers an initialization failure if an empty string is found.

Failable Initializers for Enumerations

You can use a failable initializer to select an appropriate enumeration case based on one or more parameters. The initializer can then fail if the provided parameters do not match an appropriate enumeration case.

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.”

Failable Initializers for Enumerations with Raw Values

Enumerations with raw values automatically receive a failable initializer, init?(rawValue:), that takes a parameter called rawValue of the appropriate raw-value type and selects a matching enumeration case if one is found, or triggers an initialization failure if no matching value exists. (이미 기본적으로 rawValue에 대한 failable initializer 가 제공된다.)

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.”

Propagation of Initialization Failure

(위에서 언급한 바대로 initializer가 수행되다가 fail 되면 그 순간 바로 멈춘다는 이야기)

A failable initializer of a class, structure, or enumeration can delegate across to another failable initializer from the same class, structure, or enumeration. Similarly, a subclass failable initializer can delegate up to a superclass failable initializer.

In either case, if you delegate to another initializer that causes initialization to fail, the entire initialization process fails immediately, and no further initialization code is executed.

NOTE

A failable initializer can also delegate to a nonfailable initializer. Use this approach if you need to add a potential failure state to an existing initialization process that does not otherwise fail.

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”

if let oneUnnamed = CartItem(name: “”, quantity: 1) {
   print(“Item: (oneUnnamed.name), quantity: (oneUnnamed.quantity)”)
} else {
   print(“Unable to initialize one unnamed product”)
}
// Prints “Unable to initialize one unnamed product”

Overriding a Failable Initializer

You can override a superclass failable initializer in a subclass, just like any other initializer. Alternatively, you can override a superclass failable initializer with a subclass nonfailable initializer. This enables you to define a subclass for which initialization cannot fail, even though initialization of the superclass is allowed to fail.

Note that if you override a failable superclass initializer with a nonfailable subclass initializer, the only way to delegate up to the superclass initializer is to force-unwrap the result of the failable superclass initializer.

class Document {
   var name: String?
   // this initializer creates a document with a nil name value
   init() {}
   // this initializer creates a document with a nonempty name value
   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
       }
   }
}

class UntitledDocument: Document {
   override init() {
       super.init(name: “[Untitled]”)!
   }
}

The init! Failable Initializer

You typically define a failable initializer that creates an optional instance of the appropriate type by placing a question mark after the init keyword (init?). Alternatively, you can define a failable initializer that creates an implicitly unwrapped optional instance of the appropriate type. Do this by placing an exclamation mark after the init keyword (init!) instead of a question mark.

You can delegate from init? to init! and vice versa, and you can override init? with init! and vice versa. You can also delegate from init to init!, although doing so will trigger an assertion if the init! initializer causes initialization to fail.

Required Initializers

Write the required modifier before the definition of a class initializer to indicate that every subclass of the class must implement that initializer:

class SomeClass {
   required init() {
       // initializer implementation goes here
   }
}

You must also write the required modifier before every subclass implementation of a required initializer, to indicate that the initializer requirement applies to further subclasses in the chain. You do not write the override modifier when overriding a required designated initializer:

class SomeSubclass: SomeClass {
   required init() {
       // subclass implementation of the required initializer goes here
   }
}

NOTE

You do not have to provide an explicit implementation of a required initializer if you can satisfy the requirement with an inherited initializer.

Setting a Default Property Value with a Closure or Function

If a stored property’s default value requires some customization or setup, you can use a closure or global function to provide a customized default value for that property. Whenever a new instance of the type that the property belongs to is initialized, the closure or function is called, and its return value is assigned as the property’s default value.

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

Note that the closure’s end curly brace is followed by an empty pair of parentheses. This tells Swift to execute the closure immediately. If you omit these parentheses, you are trying to assign the closure itself to the property, and not the return value of the closure.

NOTE

If you use a closure to initialize a property, remember that the rest of the instance has not yet been initialized at the point that the closure is executed. This means that you cannot access any other property values from within your closure, even if those properties have default values. You also cannot use the implicit self property, or call any of the instance’s methods.

The example below defines a structure called Chessboard, which models a board for the game of chess. Chess is played on an 8 x 8 board, with alternating black and white squares.

image

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”

Inheritance

Classes in Swift can call and access methods, properties, and subscripts belonging to their superclass and can provide their own overriding versions of those methods, properties, and subscripts to refine or modify their behavior. Swift helps to ensure your overrides are correct by checking that the override definition has a matching superclass definition.

Classes can also add property observers to inherited properties in order to be notified when the value of a property changes. Property observers can be added to any property, regardless of whether it was originally defined as a stored or computed property.

Defining a Base Class

Any class that does not inherit from another class is known as a base class.

NOTE

Swift classes do not inherit from a universal base class. Classes you define without specifying a superclass automatically become base classes for you to build upon.

class Vehicle {
   var currentSpeed = 0.0
   var description: String {
       return “traveling at (currentSpeed) miles per hour”
   }
   func makeNoise() {
       // do nothing – an arbitrary vehicle doesn’t necessarily make a noise
   }
}

let someVehicle = Vehicle()

print(“Vehicle: (someVehicle.description)”)
// Vehicle: traveling at 0.0 miles per hour

Subclassing

To indicate that a subclass has a superclass, write the subclass name before the superclass name, separated by a colon:

class SomeSubclass: SomeSuperclass {
   // subclass definition goes here
}

class Bicycle: Vehicle {
   var hasBasket = false
}

let bicycle = Bicycle()
bicycle.hasBasket = true

bicycle.currentSpeed = 15.0
print(“Bicycle: (bicycle.description)”)
// Bicycle: traveling at 15.0 miles per hour

class Tandem: Bicycle {
   var currentNumberOfPassengers = 0
}

let tandem = Tandem()
tandem.hasBasket = true
tandem.currentNumberOfPassengers = 2
tandem.currentSpeed = 22.0
print(“Tandem: (tandem.description)”)
// Tandem: traveling at 22.0 miles per hour

Overriding

A subclass can provide its own custom implementation of an instance method, type method, instance property, type property, or subscript that it would otherwise inherit from a superclass. This is known as overriding.

To override a characteristic that would otherwise be inherited, you prefix your overriding definition with the override keyword. Doing so clarifies that you intend to provide an override and have not provided a matching definition by mistake. Overriding by accident can cause unexpected behavior, and any overrides without the override keyword are diagnosed as an error when your code is compiled.

Accessing Superclass Methods, Properties, and Subscripts

Where this is appropriate, you access the super class version of a method, property, or subscript by using the super prefix:

  • An overridden method named someMethod() can call the superclass version of someMethod() by calling super.someMethod() within the overriding method implementation.
  • An overridden property called someProperty can access the superclass version of someProperty as super.someProperty within the overriding getter or setter implementation.
  • An overridden subscript for someIndex can access the superclass version of the same subscript as super[someIndex] from within the overriding subscript implementation.

Overriding Methods

class Train: Vehicle {
   override func makeNoise() {
       print(“Choo Choo”)
   }
}

let train = Train()
train.makeNoise()
// Prints “Choo Choo”

Overriding Properties

You can override an inherited instance or type property to provide your own custom getter and setter for that property, or to add property observers to enable the overriding property to observe when the underlying property value changes.

Overriding Property Getters and Setters

(참고: 

Setters and Getters apply to computed properties; such properties do not have storage in the instance – the value from the getter is meant to be computed from other instance properties.)

(ref: https://stackoverflow.com/a/24025548

You can provide a custom getter (and setter, if appropriate) to override any inherited property, regardless of whether the inherited property is implemented as a stored or computed property at source. The stored or computed nature of an inherited property is not known by a subclass—it only knows that the inherited property has a certain name and type. You must always state both the name and the type of the property you are overriding, to enable the compiler to check that your override matches a superclass property with the same name and type.

You can present an inherited read-only property as a read-write property by providing both a getter and a setter in your subclass property override. You cannot, however, present an inherited read-write property as a read-only property.

NOTE

If you provide a setter as part of a property override, you must also provide a getter for that override. If you don’t want to modify the inherited property’s value within the overriding getter, you can simply pass through the inherited value by returning super.someProperty from the getter, where someProperty is the name of the property you are overriding.

class Car: Vehicle {
   var gear = 1
   override var description: String {
       return super.description + “ in gear (gear)”
   }
}

let car = Car()
car.currentSpeed = 25.0
car.gear = 3
print(“Car: (car.description)”)
// Car: traveling at 25.0 miles per hour in gear 3

Overriding Property Observers

You can use property overriding to add property observers to an inherited property. This enables you to be notified when the value of an inherited property changes, regardless of how that property was originally implemented. For more information on property observers, see Property Observers.

NOTE

You cannot add property observers to inherited constant stored properties or inherited read-only computed properties. The value of these properties cannot be set, and so it is not appropriate to provide a willSet or didSet implementation as part of an override.

Note also that you cannot provide both an overriding setter and an overriding property observer for the same property. If you want to observe changes to a property’s value, and you are already providing a custom setter for that property, you can simply observe any value changes from within the custom setter.

class AutomaticCar: Car {
   override var currentSpeed: Double {
       didSet {
           gear = Int(currentSpeed / 10.0) + 1
       }
   }
}

let automatic = AutomaticCar()
automatic.currentSpeed = 35.0
print(“AutomaticCar: (automatic.description)”)
// AutomaticCar: traveling at 35.0 miles per hour in gear 4

Preventing Overrides

You can prevent a method, property, or subscript from being overridden by marking it as final. Do this by writing the final modifier before the method, property, or subscript’s introducer keyword (such as final var, final func, final class func, and final subscript).

You can mark an entire class as final by writing the final modifier before the class keyword in its class definition (final class). 

Subscripts

Classes, structures, and enumerations can define subscripts, which are shortcuts for accessing the member elements of a collection, list, or sequence. You use subscripts to set and retrieve values by index without needing separate methods for setting and retrieval. For example, you access elements in an Array instance as someArray[index] and elements in a Dictionary instance as someDictionary[key]

You can define multiple subscripts for a single type, and the appropriate subscript overload to use is selected based on the type of index value you pass to the subscript. Subscripts are not limited to a single dimension, and you can define subscripts with multiple input parameters to suit your custom type’s needs. 

(array나 dictionary처럼 index,key를 통해 element에 접근가능하게 하는 방법 제공한다는 이야기 그러나 꼭 index,key (string) 형식이 아니어도 상관없음)

Subscript Syntax

Subscripts enable you to query instances of a type by writing one or more values in square brackets after the instance name. Their syntax is similar to both instance method syntax and computed property syntax. You write subscript definitions with the subscript keyword, and specify one or more input parameters and a return type, in the same way as instance methods. Unlike instance methods, subscripts can be read-write or read-only. This behavior is communicated by a getter and setter in the same way as for computed properties:

subscript(index: Int) -> Int {
   get {
       // return an appropriate subscript value here
   }
   set(newValue) {
       // perform a suitable setting action here
   }
}

The type of newValue is the same as the return value of the subscript. As with computed properties, you can choose not to specify the setter’s (newValue) parameter. A default parameter called newValue is provided to your setter if you do not provide one yourself.

As with read-only computed properties, you can simplify the declaration of a read-only subscript by removing the get keyword and its braces:

subscript(index: Int) -> Int {
   // return an appropriate subscript value here
}

example of a read-only subscript implementation

struct TimesTable {
   let multiplier: Int
   subscript(index: Int) -> Int {
       return multiplier * index
   }
}
let threeTimesTable = TimesTable(multiplier: 3)
print(“six times three is (threeTimesTable[6])”)
// Prints “six times three is 18”

Subscript Usage

Subscripts are typically used as a shortcut for accessing the member elements in a collection, list, or sequence. You are free to implement subscripts in the most appropriate way for your particular class or structure’s functionality.

For example, Swift’s Dictionary type 

var numberOfLegs = [“spider”: 8, “ant”: 6, “cat”: 4]
numberOfLegs[“bird”] = 2

Subscript Options

Subscripts can take any number of input parameters, and these input parameters can be of any type. Subscripts can also return any type. Subscripts can use variadic parameters(정해지지 않은 수의 변수 즉 여러개의 parameters), but they can’t use in-out parameters(값을 받고 계산된 값을 되돌리는 경우) or provide default parameter values.

A class or structure can provide as many subscript implementations as it needs, and the appropriate subscript to be used will be inferred based on the types of the value or values that are contained within the subscript brackets at the point that the subscript is used. This definition of multiple subscripts is known as subscript overloading.

While it is most common for a subscript to take a single parameter, you can also define a subscript with multiple parameters if it is appropriate for your type. The following example defines a Matrix structure, which represents a two-dimensional matrix of Double values. The Matrix structure’s subscript takes two integer parameters:

struct Matrix {
   let rows: Int, columns: Int
   var grid: [Double]
   init(rows: Int, columns: Int) {
       self.rows = rows
       self.columns = columns

       // 첫번째 파라미터는 값, 두번째 파라미터는 array 요소의 갯수

       // 참조 

Creating an Array with a Default Value.

       grid = Array(repeating: 0.0, count: rows * columns)
   }
   func indexIsValid(row: Int, column: Int) -> Bool {
       return row >= 0 && row < rows && column >= 0 && column < columns
   }
   subscript(row: Int, column: Int) -> Double {
       get {
           assert(indexIsValid(row: row, column: column), “Index out of range”)
           return grid[(row * columns) + column]
       }
       set {
           assert(indexIsValid(row: row, column: column), “Index out of range”)
           grid[(row * columns) + column] = newValue
       }
   }
}

var matrix = Matrix(rows: 2, columns: 2)

matrix[0, 1] = 1.5
matrix[1, 0] = 3.2

func indexIsValid(row: Int, column: Int) -> Bool {
   return row >= 0 && row < rows && column >= 0 && column < columns
}

let someValue = matrix[2, 2]
// this triggers an assert, because [2, 2] is outside of the matrix bounds

Swift type properties – Cosmin Mircea – Medium

All about Properties in swift – Abhimuralidharan – Medium

Reference and Value Types in Swift – Andrea Prearo – Medium