Automatic reference counting is very easy to understand. Imagine that we have to distribute the items that we store in a box. After we distribute all the items, we must throw the box in a recycle bin. We cannot throw the box in the recycle bin when we still have one or more items in it. Seriously, we don't want to lose the items we have to distribute because they are very expensive.

The problem has a very easy solution; we just need to count the number of items that remain in the box. When the number of items in the box reaches zero, we can get rid of the box.

For example, you...

The following lines declare a new minimal Circle class in Swift. The code file for the sample is included in the swift_3_oop_chapter_02_01 folder:

    class Circle { 
    } 

The class keyword, followed by the class name (Circle), composes the header of the class definition. In this case, the class doesn't have a parent class or superclass; therefore, there are neither superclasses listed after the class name nor a colon (:). A pair of curly braces ({}) encloses the class body after the class header. In the forthcoming chapters, we will declare classes that inherit from another class, and therefore, they will have a superclass. In this case, the class body is empty. The Circle class is the simplest possible class we can declare in Swift.

We want to initialize instances of the Circle class with the radius value. In order to do so, we can take advantage of customized initializers. Initializers aren't methods, but we will write them with syntax that is very similar to the instance methods. They will use the init keyword to differentiate from instance methods, and Swift will execute them automatically when we create an instance of a given type. Swift runs the code within the initializer before any other code within a class.

We can define an initializer that receives the radius value as an argument and use it to initialize a property with the same name. We can define as many initializers as we want to, and therefore, we can provide many different ways of initializing a class. In this case, we just need one initializer.

The following lines create a Circle class and define an initializer within the class body. The code file for the sample is included in the swift_3_oop_chapter_02_02 folder:

    class Circle...

We want to know when the instances of the Circle class will be removed from memory; that is, when the objects aren't referenced by any variable and automatic reference count mechanism decides that they have to be removed from memory. Deinitializers are special parameterless class methods that are automatically executed just before the runtime destroys an instance of a given type. Thus, we can use them to add any code we want to run before the instance is destroyed. We cannot call a deinitializer; they are only available for the runtime.

The deinitializer is a special method that uses the deinit keyword in its declaration. The declaration must be parameterless, and it cannot return a value.

The following lines declare a deinitializer within the body of the Circle class:

    deinit { 
      print("I'm destroying the Circle instance with a 
      radius value of \(radius).") 
    } 

The following lines show the new complete code for the Circle class. The code file...

The following lines create an instance of the Circle class named circle within the scope of a generatedCircleRadius function. The code within the function uses the created instance to access and return the value of its radius property. In this case, the code uses the let keyword to declare an immutable reference to the Circle instance named circle. An immutable reference is also known as a constant reference because we cannot replace the reference held by the circle constant to another instance of Circle. When we use the var keyword, we declare a reference that we can change later.

After we define the new function, we will call it. Note that the screenshot displays the results of the execution of the initializer and then the deinitializer. Swift destroys the instance after the circle constant goes out of scope because its reference count goes down from one to zero; therefore, there is no reason to keep the instance alive. Enter the following lines in the...

Now that you understand an instance's life cycle, it is time to spend some time in the Playground, the Swift REPL, or the Swift Sandbox, creating new classes and instances:

In this chapter, you learned about an object's life cycle. You also learned how object initializers and deinitializers work. We declared our first class to generate a blueprint for objects. We customized object initializers and deinitializers and tested their personalized behavior in action with live examples in Swift's Playground. We understood how they work in combination with automatic reference counting. You also learned how we can run the samples in the Swift REPL and the web-based Swift Sandbox.

Now that you have learned to start creating classes and instances, you are ready to share, protect, use, and hide data with the data encapsulation features included in Swift, which is the topic of the next chapter.