Object-Oriented Features

Throughout the past couple of lessons, we've been learning how to use Swift syntax, variables, functions, and control flow structures to develop the building blocks of Swift applications. In the final section of this lesson, we'll learn how to pull all those language components together into Swift's object-oriented classes and structures—the high-level building blocks of most professional Swift applications.

Object-Oriented Principles

Swift is an object-oriented programming language, and enables the core principles of object-oriented programming. Generally speaking, in object-oriented programming, variables, functions and data structures that implement a functional unit of your program are combined into an object that exists within its own namespace, and is accessed by other objects through filtered, publicly exposed interfaces.

Using Swift, instances are created using both structs and classes. Structs and classes support encapsulation and abstraction, though only classes support inheritance. Both object types—structs and classes—are frequently used in Swift, and neither is better than the other for all use cases.

Classes Versus Structs

Virtually all object-oriented languages are based on the concept of organizing units of code into classes that perform a very specific set of actions on a specific set of data.

Illustration

A class can be thought of as a pattern, such as one a clothes factory might place over a bolt of fabric to cut a new shirt. The pattern (class) has all the dimensions and notations that describe to the tailor what shape the shirt will take. The tailor can use the pattern to create as many shirts as they need—each one perfectly formed by placing the pattern on the raw fabric and cutting around the pattern. Here, the tailor is the Swift runtime, the pattern is the class (or struct) designed by the programmer, and the finished shirt is an object generated by the Swift runtime environment.

While this section isn't a comprehensive tutorial on object-oriented programming, some general guidelines for selecting between classes and structs are the following:

• Structs are value types, which are always copied when passed between objects or assigned to variables. This makes them ideal to use when creating objects that are primarily used to store data structures (though structs can and do include functions that operate on their data).
• Classes support inheritance, which makes them the only alternative when defining objects that will serve as base classes or be derived from base classes.
• Classes, as reference types, are also a better choice when it's advantageous to pass an object by reference, allowing its members to be directly modified by functions it's passed to (this is somewhat similar to the inout parameter distinction we learned earlier in this lesson).

Defining Classes and Structures

In this lesson, we'll focus on the syntax to define, instantiate, and use your own structs and classes. These techniques are nearly the same for each object type.

A class or struct is defined with the following syntax:

• The struct or class keyword defines a namespace for the class. This namespace is prepended to any symbol definition within the scope of the struct or class when your application is assembled.
• The definition of struct or class members is enclosed in braces ({…}).
• If a class or struct contains member variables that are not assigned default values where defined, an initializer must be provided so the uninitialized member variables can be assigned a value. For structs (but not for classes), the Swift compiler will create an initializer for you.
• Within the definition braces, variables and functions can be added, according to the techniques learned in the last couple of lessons.
• Classes, structs, and their enclosed methods and variables can be given specific access levels, which control how visible they will be from outside modules. The default access level is Internal, which makes all elements visible to any code in the same module.

The following are declarations for a Customer object—the first declared as a struct and the second as a class:

struct Customer {
   var name: String
   var customerNumber: String
}

class Customer {
   var name: String
   var customerNumber: String
}

Throughout the last couple of lessons, you've been using structs and classes, for example:

• The String type is a struct that contains many properties and functions—for example, the .count property we often used to count the characters contained in a string.
• We used the JSONDecoder class to decode the JSON text in Activity B.

As you develop applications with Swift, you'll use classes and structs frequently, and will often define your own.

Next, you'll solidify your understanding of basic struct and class usage by practicing the creation of each type of object in an activity.

Activity C: Creating a Customer Struct and Class

To compare the differences (and similarities) between Swift classes and structs, it's useful to implement the same data structure in both. This is exactly what we'll do now.

Use an Xcode playground to practice how to create Swift structs and classes.

1. Launch Xcode and create a new playground, then save it to your desktop with the name CustomerStructClass.playground.
2. Add the following lines of code to declare a new Customer struct:

   struct CustomerStruct {
   }

3. Below the closing brace of the struct definition, create a new variable of type Customer. Congratulations! You've created a struct definition, and instantiated your first custom object!

   var customer1 = CustomerStruct()

4. Modify the code to the following, adding the enum CustomerType and variable type to the struct. Then modify your code to print the current customer.type to the debug console:

   struct CustomerStruct {
       enum CustomerType: String {
           case gold = "Gold Customer!"
           case silver = "Silver Customer!"
           case unknown = "Unknown customer type"
       }
   
       var type: CustomerType?
   }
   
   var customer1 = CustomerStruct()
   
   print(customer1.type ?? "invalid customer type")

   • At this point, the print statement prints invalid customer type, because the member variable within the struct is initialized to an optional having a nil value.
5. Because this is a struct, Swift has auto-created an initializer we can use to set an initial value for the customer value. Modify the instantiation of the customer variable as follows:

   var customer = CustomerStruct(type: .gold)

   • Now when the code runs, the output is the string gold.
6. Creating a similar data structure as a class is quite similar. Add the following class definition to your playground:

   class CustomerClass {
       enum CustomerType: String {
           case gold = "Gold Customer!"
           case silver = "Silver Customer!"
           case unknown = "Unknown customer type"
       }
   
       var type: CustomerType?
   
       init(type:CustomerType) {
           self.type = type
       }
   }

   • This definition declares a class of type CustomerClass. Because Swift does not automatically create initializers for classes, CustomerClass includes an initializer to allow its CustomerType variable to be set on instantiation—just as the automatically created struct initializer does for CustomerStruct.
7. Finally, add the following two lines to the playground to instantiate an object of type CustomerClass, and print its type enum member to the debug console:

   var customer2 = CustomerClass(type: .silver)
   print(customer2.type ?? "invalid customer type")