Whenever you have to solve a problem in the real world, you use elements and interact with them. For example, when you are thirsty, you take a glass, you fill it up with water, soda, or your favorite juice, and then you drink. Similarly, you can easily recognize elements, known as objects, from real-world actions and then translate them into object-oriented code. In this chapter, we will start learning the principles of object-oriented programming to use them in Swift 3 to develop apps and applications.

In case we want to work with Swift 3 in Ubuntu Linux, we won't be able to run the examples that interact with any iOS API. However, we will be able to run a big percentage of the sample code included in this book, and we will be able to learn the most important object-oriented principles.

We can download the latest release for our Ubuntu version in theDOWNLOAD section athttp://swift.org. This page includes all the instructions to install the required dependencies (clang andlibicu-dev) and to execute the Swift REPL command-line environment.

Once we have completed the installation, we can execute theswift command to run the REPL in a Terminal. After we see a welcome message, we can enter Swift code and the REPL will display the results of executing each code block. We can also take advantage of a set of LLDB debugging commands. We just need to enter:help to list all the available debugger commands.

The following screenshot shows the Terminal application in Ubuntu running theswift command and displaying the results after entering two lines of Swift code:

In case we want to work with Swift 3 in Windows or in any other platform, we can work with a web-based Swift sandbox developed by IBM. We just need to open the following web page in a web browser:https://swiftlang.ng.bluemix.net/#/repl.

The IBM Swift Sandbox mimics the Playground with a text-based UI and it allows you to enter the code on the left-hand side and watch the results of the execution on the right-hand side. The sandbox is simple and not as powerful as the Xcode Playground. As it happens with Swift in Ubuntu Linux, we won't be able to run the examples that interact with any iOS API. However, we will be able to run a big percentage of the sample code included in this book, and we will be able to learn the most important object-oriented principles with any compatible web browser.

The following screenshot shows IBM Swift Sandbox displaying the results of executing two lines of Swift code in Chrome under Windows 10. We just need to enter the Swift code on the left-hand side and click on the Execute button (play icon) to see the results of compiling and executing the code on the right-hand side:

Now, let's forget about Xcode and Swift for a while. Imagine that we have to develop a new universal iOS app that targets the iPad, iPhone, and iPod touch devices. We will have differentUser Interfaces(UI) andUser Experiences(UX) because these devices have diverse screen sizes and resolutions. However, no matter the device in which the app runs, it will have the same goal.

Imagine that Vanessa is a very popular YouTuber, painter, and craftswoman who usually uploads videos on a YouTube channel. She has more than a million followers, and one of her latest videos had a huge impact on social networking sites. In this video, she sketched basic shapes and then painted them with acrylic paint to build patterns. She worked with very attractive colors, and many famous Hollywood actresses uploaded pictures on Instagram sharing their creations with the technique demonstrated by Vanessa and with the revolutionary special colors developed by a specific acrylic paint manufacturer.

Obviously, the acrylic paint manufacturer wants to take full advantage of this situation, so he specifies the requirements for an app. The app must provide a set of predefined 2D shapes that the users can drag and drop in a document to build a pattern so that they can change both the 2D position and size. It is important to note that the shapes cannot intersect, and users cannot change the line widths because these are the basic requirements of the technique introduced by Vanessa. A user can select the desired line and fill colors for each shape. At any time, the user can tap a button, and the app must display a list of the acrylic paint tubes, bottles, or jars that the user must buy to paint the drawn pattern. Finally, the user can easily place an online order to request the suggested acrylic paint tubes, bottles, or jars. The app also generates a tutorial to explain to the user how to generate each of the final colors for the lines and fills by thinning the appropriate amount of acrylic paint with water, based on the colors that the user has specified.

The following figure shows an example of a pattern. Note that it is extremely simple to describe the objects that compose the pattern: four 2D shapes-specifically, two rectangles and two circles. If we measure the shapes, we would easily realize that they aren't two squares and two ellipses; they are two rectangles and two circles:

We can easily recognize the objects; we understand that the pattern is composed of many 2D geometric shapes. Now, let's focus on the core requirement for the app, which is calculating the required amounts of acrylic paint. We have to take into account the following data for each shape included in the pattern in order to calculate the amount of acrylic paint:

The app allows users to use a specific color for the line that draws the borders of each shape. Thus, we have to calculate the perimeter in order to use it as one of the values that will allow us to estimate the amount of acrylic paint that the user must buy to paint each shape's border. Then, we have to calculate the area to use it as one of the values that will allow us to estimate the amount of acrylic paint that the user must buy to fill each shape's area.

We have to start working on the backend code that calculates areas and perimeters. The app will follow Vanessa's guidelines to create the patterns, and it will only support the following six shapes:

We can start writing Swift code-specifically, six functions that calculate the areas of the previously enumerated shapes and another six to calculate their perimeters. Note that we are talking about functions, and we stopped thinking about objects; therefore, we will face some problems with this path, which we will solve with an object-oriented approach from scratch.

For example, if we start thinking about functions to solve the problem, one possible solution is to code the following twelve functions to do the job:

Each of the previously enumerated functions has to receive the necessary parameters of each shape and return either its calculated area or perimeter. These functions do not have side effects, that is, they do not make changes to the arguments they receive and they just return the results of the calculated perimeters. Therefore, we usecalculated instead ofcalculate as the first word for their names. This way, it will be easier for us to generate the object-oriented version as we will continue to follow the API design guidelines that Apple has provided for Swift 3.

Now, let's forget about functions for a bit. Let's recognize the real-world objects from the application's requirements that we were assigned. We have to calculate the areas and perimeters of six elements, which are six nouns in the requirements that represent real-life objects-specifically 2D shapes. Our list of real-world objects is exactly the same that Vanessa's specification uses to determine the shapes allowed to be used to create patterns. Take a look at the list:

After recognizing the real-life objects, we can start designing our application by following an object-oriented paradigm. Instead of creating a set of functions that perform the required tasks, we can create software objects that represent the state and behavior of a square, equilateral triangle, rectangle, circle, ellipse, and regular hexagon. This way, the different objects mimic the real-world 2D shapes. We can work with the objects to specify the different attributes required to calculate the area and perimeter. Then, we can extend these objects to include the additional data required to calculate other required values, such as the quantity of acrylic paint required to paint the borders.

Now, let's move to the real world and think about each of the previously enumerated six shapes. Imagine that we have to draw each of the shapes on paper and calculate their areas and perimeters. After we draw each shape, which values will we use to calculate their areas and perimeters? Which formulae will we use?

The following figure shows a drawn square and the formulae that we will use to calculate the perimeter and area. We just need the length of a side, usually identified asa:

The following figure shows a drawn equilateral triangle and the formulae that we will use to calculate the perimeter and area. This type of triangle has equal sides, and the three internal angles are equal to 60 degrees. We just need the length of each side, usually identified asa:

The following figure shows a drawn rectangle and the formulae that we will use to calculate the perimeter and area. We need the width and height values:

The following figure shows a drawn circle and the formulae that we will use to calculate the perimeter and area. We just need the radius, usually identified asr:

The following figure shows a drawn ellipse and the formulae that we will use to calculate the perimeter and area. We need the semimajor axis (usually labeled asa) and semiminor axis (usually labeled asb) values:

The following figure shows a drawn regular hexagon and the formulae that we will use to calculate the perimeter and area. We just need the length of each side, usually labeled asa:

The following table summarizes the data required for each shape:

Each object that represents a specific shape encapsulates the required data that we identified. For example, an object that represents an ellipse will encapsulate the ellipse's semimajor and semiminor axes.

Imagine that you want to draw and calculate the areas of six different ellipses. You will end up with six ellipses drawn, their different semimajor axis and semiminor axis values, and their calculated areas. It would be great to have a blueprint to simplify the process of drawing each ellipse with their different semimajor axis and semiminor axis values.

In object-oriented programming, a class is a template definition or blueprint from which objects are created. Classes are models that define the state and behavior of an object. After declaring a class that defines the state and behavior of an ellipse, we can use it to generate objects that represent the state and behavior of each real-world ellipse:

The following figure shows two circle instances drawn with their radius values specified:Circle #1 andCircle #2. We can use aCircle class as a blueprint to generate the two differentCircle instances. Note thatCircle #1 has a radius value of175, andCircle #2 has a radius value of350. Each instance has a different radius value:

The following figure shows three ellipse instances drawn with their semimajor axis and semiminor axis values specified:Ellipse #1,Ellipse #2, andEllipse #3. In this case, we can use anEllipse class as a blueprint to generate the three different ellipse instances. It is very important to understand the difference between a class and the objects or instances generated through its usage. The object-oriented programming features supported in Swift allow us to discover which blueprint we used to generate a specific object. We will use these features in many examples in the upcoming chapters. Thus, we can know that each object is an instance of theEllipse class. Each ellipse has its own specific values for the semimajor and semiminor axes:

We recognized six completely different real-world objects from the application's requirements, and therefore, we can generate the following six classes to create the necessary objects:

Note the usage of Pascal case for class names; this means that the first letter of each word that composes the name is capitalized, while the other letters are in lowercase. This is a coding convention in Swift. For example, we use theRegularHexagon name for the class that will generate regular hexagons. Pascal case is also known as UpperCamelCase or Upper Camel Case.

We know the information required for each of the shapes to achieve our goals. Now, we have to design the classes to include the necessary properties that provide the required data to each instance. We have to make sure that each class has the necessary variables that encapsulate all the data required by the objects to perform all the tasks based on our application domain.

Let's start with theRegularHexagon class. It is necessary to know the length of a side for each instance of this class, that is, for each regular hexagon object. Thus, we need an encapsulated variable that allows each instance of theRegularHexagon class to specify the value for the length of a side.

TheRegularHexagon class defines a floating point property namedlengthOfSide, whose initial value is equal to0 for any new instance of the class. After we create an instance of theRegularHexagon class, it is possible to change the value of thelengthOfSide attribute.

Note the usage of Camel case, which is using a lowercase first letter, for class property names. The first letter is lowercase, and then, the first letter for each word that composes the name is capitalized, while the other letters are in lowercase. It is a coding convention in Swift for both variables and properties. For example, we use thelengthOfSide name for the property that stores the value of the length of a side.

Imagine that we create two instances of theRegularHexagon class. One of the instances is namedregularHexagon1 and the other,regularHexagon2. The instance names allow us to access the encapsulated data for each object, and therefore, we can use them to change the values of the exposed properties.

Swift uses a dot (.) to allow us to access the properties of instances. So,regularHexagon1.lengthOfSide provides access to the length of side of theRegularHexagon instance namedregularHexagon1, andregularHexagon2.lengthOfSide does the same for theRegularHexagon instance namedregularHexagon2.

We can assign20 toregularHexagon1.lengthOfSide and50 toregularHexagon2.lengthOfSide. This way, eachRegularHexagon instance will have a different value for thelengthOfSide attribute.

Now, let's move to theEllipse class. We can define two floating point attributes for this class:semiMajorAxis andsemiMinorAxis. Their initial values will also be0. Then, we can create three instances of theEllipse class namedellipse1,ellipse2, andellipse3.

We can assign the values summarized in the following table to the three instances of theEllipse class:

This way,ellipse1.semiMinorAxis will be equal to210, whileellipse3.semiMinorAxis will be equal to180. Theellipse1 instance represents an ellipse withsemiMinorAxis of210 andsemiMajorAxis of400.

The following table summarizes the floating point properties defined for each of the six classes that we need for our application:

Note that three of these classes have the same property:lengthOfSide-specifically, theSquare,EquilateralTriangle, andRegularHexagon classes. We will dive deep into what these three classes have in common later and take advantage of object-oriented features to reuse code and simplify our application's maintenance. However, we are just starting our journey, and we will make improvements as we cover additional object-oriented features included in Swift.

The following figure shows aUnified Modeling Language(UML) class diagram with the six classes and their properties. This diagram is very easy to understand. The class name appears on the top of the rectangle that identifies each class. A rectangle below the same shape that holds the class name displays all the property names exposed by the class with a plus sign (+) as a prefix. This prefix indicates that what follows it is an attribute name in UML and a property name in Swift:

So far, we have designed six classes and identified the necessary properties for each of them. Now, it is time to add the necessary pieces of code that work with the previously defined properties to perform all the tasks. We have to make sure that each class has the necessary encapsulated functions that process the property values specified in the objects to perform all the tasks.

Let's forget a bit about the similarities between the different classes. We will work with them individually as if we didn't have the necessary knowledge of geometric formulae. We will start with theSquare class. We need pieces of code that allow each instance of this class to use the value of thelengthOfSide property to calculate the area and perimeter.

When a method doesn't require parameters, we can say that it is a parameterless method. In this case, all the methods we will initially define for the classes will be parameterless methods that just work with the values of the previously defined properties and use the formulae shown in the figures. Thus, we will be able to call them without arguments. We will start creating methods, but we will be able to explore additional options based on specific Swift features later.

TheSquare class defines the following two parameterless methods. We will declare the code for both methods within the definition of theSquare class so that they can access thelengthofSide property value:

Note the usage of Camel case, that is, using a lowercase first letter, for method names. The first letter is in lowercase, and then, the first letter for each word that composes the name is capitalized, while the other letters are in lowercase. As it happened with property names, it is a coding convention in Swift for methods.

These methods do not have side effects, that is, they do not make changes to the related instance. The methods just return the calculated values. Their operation is naturally described by thecalculate verb. We usecalculated instead ofcalculate as the first word for their names because the verb's imperative must be used for mutating methods. In this case, the methods are nonmutating, and we follow the API design guidelines that Apple provided for Swift 3.

Swift uses a dot (.) to allow us to execute the methods of the instances. Imagine that we have two instances of theSquare class:square1 with thelengthOfSide property equal to20 andsquare2 with thelengthOfSide property equal to40. If we callsquare1.calculatedArea, it will return the result of20², which is 400. If we callsquare2.calculatedArea, it will return the result of40², which is 1600. Each instance has a diverse value for thelengthOfSide attribute, and therefore, the results of executing thecalcualteArea method are different.

If we callsquare1.calculatedPerimeter, it will return the result of4 * 20, which is 80. On the other hand, if we callsquare2.calculatePerimeter, it will return the result of4 * 40, which is 160.

Now, let's move to theEquilateralTriangle class. We need exactly two methods with the same names specified for theSquare class:calculatedArea andcalculatedPerimeter. In addition, the methods return the same type and don't need parameters, so we can declare both of them as parameterless methods, as we did in theSquare class. However, these methods have to calculate the results in a different way, that is, they have to use the appropriate formulae for an equilateral triangle. The other classes also need the same two methods. However, each of them will use the appropriate formulae for the related shape.

We have a specific problem with thecalculatedPerimeter method that theEllipse class generates. Perimeters are complex to calculate for ellipses, so there are many formulae that provide approximations. An exact formula requires an infinite series of calculations. We can use an initial formula that isn't very accurate, which we will have to improve later. The initial formula will allow us to return a floating point value with the calculated approximation of the perimeter for the ellipse.

The following figure shows an updated version of the UML diagram with the six classes, their attributes, and their methods:

So far, our object-oriented solution includes six classes with their properties and methods. However, if we take another look at these six classes, we will notice that all of them have the same two methods:calculatedArea andcalculatedPerimeter. The code for the methods in each class is different because each shape uses a special formula to calculate either the area or the perimeter. However, the declarations, contracts, or protocols for the methods are the same. Both methods have the same name, are always parameterless, and return a floating point value. Thus, all of them return the same type.

When we talked about the six classes, we said we were talking about six different geometrical shapes or simply shapes. Thus, we can generalize the required behavior or protocol for the six shapes. These shapes must define thecalculatedArea andcalculatedPerimeter methods with the previously explained declarations. We can create a protocol to make sure that the six classes provide the required behavior.

The protocol is a special class namedShape, and it generalizes the requirements for the geometrical shapes in our application. In this case, we will work with a special class, but in the future, we will use protocols for the same goal. TheShape class declares two parameterless methods that return a floating point value:calculatedArea andcalculatedPerimeter. Then, we will declare the six classes as subclasses of theShape class, which will inherit these definitions, and provide the specific code for each of these methods.

The subclasses ofShape (Square,EquilateralTriangle,Rectangle,Circle,Ellipse, andRegularHexagon) implement the methods because they provide code while maintaining the same method declarations specified in theShape superclass.Abstraction andhierarchy are two major pillars of object-oriented programming.

Object-oriented programming allows us to discover whether an object is an instance of a specific superclass. After we change the organization of the six classes and after they become subclasses ofShape, any instance ofSquare,EquilateralTriangle,Rectangle,Circle,Ellipse, orRegularHexagon is also aShape class. In fact, it isn't difficult to explain the abstraction because we speak the truth about the object-oriented model when we say that it represents the real world. It makes sense to say that a regular hexagon is indeed a shape and therefore an instance ofRegularHexagon is aShape class. An instance ofRegularHexagon is both aShape (the superclass ofRegularHexagon) class and aRegularHexagon (the class that we used to create the object) class.

The following figure shows an updated version of the UML diagram with the superclass or base class (Shape), its six subclasses, and their attributes and methods. Note that the diagram uses a line that ends in an arrow that connects each subclass to its superclass. You can read the line that ends in an arrow as the following: the class where the line beginsis a subclass of the class that has the line ending with an arrow. For example,Square is a subclass ofShape andEquilateralTriangle is a subclass ofShape:

Now, it is time to have a meeting with a domain expert, that is, someone who has an excellent knowledge of geometry. We can use the UML diagram to explain the object-oriented design for the solution. After we explain the different classes that we will use to abstract behavior, the domain expert explains to us that many of the shapes have something in common and that we can generalize behavior even further. The following three shapes are regular polygons:

Regular polygons are polygons that are both equiangular and equilateral. All the sides that compose a regular polygon have the same length and are placed around a common center. This way, all the angles between any two sides are equal. An equilateral triangle is a regular polygon with three sides, the square has four sides, and the regular hexagon has six sides. The following picture shows the three regular polygons and the generalized formulae that we can use to calculate their areas and perimeters. The generalized formula to calculate the area requires us to calculate a cotangent, which is abbreviated ascot:

As the three shapes use the same formula with just a different value for the number of sides (n) parameter, we can generalize the required protocol for the three regular polygons. The protocol is a special class namedRegularPolygon that defines a newnumberOfSides property that specifies the number of sides with an integer value. TheRegularPolygon class is a subclass of the previously definedShape class. It makes sense because a regular polygon is indeed a shape. The three classes that represent regular polygons become subclasses ofRegularPolygon. However, both thecalculateArea andcalculatedPerimeter methods are coded in theRegularPolygon class using the generalized formulae. The subclasses just specify the right value for the inheritednumberOfSides property, as follows:

TheRegularPolygon class also defines thelengthOfSide property that was previously defined in the three classes that represent regular polygons. Now, the three classes become subclasses ofRegularPolygon and inherit thelengthOfSide property. The following figure shows an updated version of the UML diagram with the newRegularPolygon class and the changes in the three classes that represent regular polygons. The three classes that represent regular polygons do not declare either thecalculatedArea orcalculatedPerimeter methods because these classes inherit them from theRegularPolygon superclass and don't need to make changes to these methods that apply a general formula:

Our domain expert also explains to us a specific issue with ellipses. There are many formulae that provide approximations of the perimeter value for this shape. Thus, it makes sense to add additional methods that calculate the perimeter using other formulae. He suggests us to make it possible to calculate the perimeters with the following formulae:

We will define the following two additional parameterless methods to theEllipse class. The new methods will return a floating point value and solve the specific problem of the ellipse shape:

This way, theEllipse class will implement the methods specified in theShape superclass and also add two specific methods that aren't included in any of the other subclasses ofShape. The following figure shows an updated version of the UML diagram with the new methods for theEllipse class:

Now, let's forget a bit about geometry, shapes, polygons, perimeters, and areas. We will interact with API objects in the Xcode Playground. You still need to learn many things before we can start creating object-oriented code. However, we will write some code in the Playground to interact with an existing API before we move forward with our journey into the object-oriented programming world.

Object-oriented programming is extremely useful when you have to interact with API objects. When Apple launched iOS 8, it introduced a Health app that provided iPhone users access to a dashboard of health and fitness data. TheHealthKit framework introduced in the iOS SDK 8 allows app developers to request permissions from the users themselves to read and write specific types of health and fitness data. The framework makes it possible to ask for, create, and save health and fitness data that the users will see summarized in the Health app. This app is still a very important app in iOS 10, and the Apple Watch device in its two versions can generate very useful data for this app.

When we store and query health and fitness data, we have to use the framework to work with the units in which the values are expressed, their conversions, and localizations. For example, let's imagine an app that stores body temperature data without considering the units and their conversions. A value of 39 degrees Celsius (which is equivalent to 102.2 degrees Fahrenheit) in an adult would means that the person's body temperature is higher than normal (that is, they may have a fever). However, a value of 39 degrees Fahrenheit (equivalent to 3.88 degrees Celsius) would mean that the person's body is close to its freezing point. If our app just stores values without considering the related units and user preferences, we can have huge mistakes. If the app just saves 39 degrees and thinks that the user will always display Celsius, it will still display 39 degrees to a user whose settings use Fahrenheit as the default temperature unit. Thus, the app will provide wrong information to the user.

The data in HealthKit is always represented by a double value with an associated simple or complex unit. The units are classified into types, and it is possible to check the compatibility between units before performing conversions. We can work with HealthKit quantities and units in the Swift interactive Playground and understand how simple it is to work with an object-oriented framework. It is important to note that the Playground doesn't allow us to interact with the HealthKit data store. However, we will just play with quantities and units in a few object-oriented snippets.

Start Xcode, navigate toFile |New |Playground..., enter a name forPlayground, selectiOS as the desired platform, click onNext, select the desired location for the Playground file, and click onCreate. Xcode will display a Playground window with a line that importsUIKit and creates astring variable. You just need to add the following line to be able to work with quantities and units from theHealthKit framework, as shown in the subsequent screenshot:

    import HealthKit

AllHealthKit types start with theHK prefix.HKUnitrepresents a particular unit that can be either simple or complex. Simple units for temperature are degrees Celsius and degrees Fahrenheit. A complex unit for mass/volume is ounces per liter (oz/L).HKUnitsupports many standardSI units (Système Internationale d'Unités in French,International System of Units in English) and non-SI units.

Add the following two lines to the Swift Playground and check the results on the right-hand side of the window; you will notice that they generate instances ofHKTemperatureUnit. Thus, you created two objects that represent temperature units, as follows. The code file for the sample is included in theswift_3_oop_chapter_01_01 folder:

    let degCUnit = HKUnit.degreeCelsius()     let degFUnit = HKUnit.degreeFahrenheit()

However, there are other ways to create objects that represent temperature units. It is also possible to use theHKUnit initializer, which returns the appropriate unit instance from its string representation. For example, the following lines also generate instances ofHKTemperatureUnit for degrees in Celsius and Fahrenheit. The code file for the sample is included in theswift_3_oop_chapter_01_01 folder:

    let degCUnitFromStr = HKUnit(from: "degC")     let degFUnitFromStr = HKUnit(from: "degF")

The following lines generate two instances ofHKEnergyUnit-one for kilocalories and the other for kilojoules. The code file for the sample is included in theswift_3_oop_chapter_01_01 folder:

    let kiloCaloriesUnit = HKUnit(from: "kcal")     let joulesUnit = HKUnit(from: "kJ")

The next two lines generate two instances ofHKMassUnit-one for kilograms and the other for pounds. The code file for the sample is included in theswift_3_oop_chapter_01_01 folder:

    let kiloGramsUnit = HKUnit.gramUnit(with:     HKMetricPrefix.kilo)     let poundsUnit = HKUnit.pound()

The next line generates an instance of _HKCompoundUnit because the string specifies a complex unit for mass/volume: ounces per liter (oz/L). The code file for the sample is included in theswift_3_oop_chapter_01_01 folder. The subsequent screenshot shows the results displayed in the Playground:

    let ouncesPerLiter = HKUnit(from: "oz/L")

HKQuantity encapsulates a quantity value (Double) and the unit of measurement (HKUnit). This class doesn't provide all the operations you might expect to work with quantities and their units of measure, but it allows you to perform some useful compatibility checks and conversions.

The following lines create twoHKQuantity instances with temperature units; we name the instancesbodyTemperature1 andbodyTemperature2. The former uses degrees Celsius (degCUnit) and the latter degrees Fahrenheit (degFUnit). Then, the code calls theis method with thecompatibleWith argument to make sure that eachHKQuantity instance can be converted to degrees Fahrenheit (degFUnit). Ifis returnstrue, it means that you can convert toHKUnit, which is specified as thecompatibleWith argument. We always have to call this method before calling thedoubleValue method. This way, we will avoid errors when the units aren't compatible.

ThedoubleValue method returns the quantity value converted to the unit specified as thefor argument. In this case, the two calls make sure that the value is expressed in degrees Fahrenheit, no matter what the temperature unit specified in eachHKQuantity instance is. The code file for the sample is included in theswift_3_oop_chapter_01_01 folder. The screenshot that follows the given code shows the results displayed in the Playground:

    let bodyTemperature1 = HKQuantity(unit: degCUnit,     doubleValue: 35.2)     let bodyTemperature2 = HKQuantity(unit: degFUnit,     doubleValue: 95)     print(bodyTemperature1.description)     print(bodyTemperature2.description)      if bodyTemperature1.is(compatibleWith: degFUnit) {       print("Temperature #1 in Fahrenheit degrees: \      (bodyTemperature1.doubleValue(for: degFUnit))")     }      if bodyTemperature2.is(compatibleWith: degFUnit) {       print("Temperature #2 in Fahrenheit degrees: \      (bodyTemperature2.doubleValue(for: degFUnit))")     }

The following line shows an example of the code that creates a newHKQuantity instance with a quantity and temperature unit converted from degrees Fahrenheit to degrees Celsius. There is no convert method that acts as a shortcut, so we have to calldoubleValue and use it in theHKQuantity initializer, as follows. The code file for the sample is included in theswift_3_oop_chapter_01_01 folder:

    let bodyTemperature2InDegC = HKQuantity(unit:       degCUnit, doubleValue:     bodyTemperature2.doubleValue(for: degCUnit))

Thecompare method returns aComparisonResult value that indicates whether the receiver is greater than, equal to, or less than the compatibleHKQuantity value specified as an argument. For example, the following lines comparebodyTemperature1 withbodyTemperature2 and print the results of the comparison. Note that it isn't necessary to convert both theHKQuantity instances to the same unit; they just need to be compatible, and the compare method will be able to perform the comparison by making the necessary conversions under the hood. In this case, one of the temperatures is in degrees Celsius and the other is in degrees Fahrenheit. The screenshot that follows the given code shows the results displayed in the Playground:

    let bodyTemperature2InDegC = HKQuantity(unit:       degCUnit, doubleValue:     bodyTemperature2.doubleValue(for: degCUnit))      let comparisonResult =     bodyTemperature1.compare(bodyTemperature2)     switch comparisonResult {       case ComparisonResult.orderedDescending:       print("Temperature #1 is greater than #2")       case ComparisonResult.orderedAscending:       print("Temperature #2 is greater than #1")       case ComparisonResult.orderedSame:       print("Temperature #1 is equal to Temperature #2")     }

Now that you understand what an object is, it is time to recognize objects in different applications:

In this chapter, you learned how to recognize real-world elements and translate them into the different components of the object-oriented paradigm supported in Swift 3: classes, protocols, properties, methods, and instances. You understood that the classes represent blueprints or templates to generate the objects, also known as instances.

We designed a few classes with properties and methods that represent blueprints for real-life objects. Then, we improved the initial design by taking advantage of the power of abstraction and specialized different classes. We generated many versions of the initial UML diagram as we added superclasses and subclasses. Finally, we wrote some code in the Swift Playground to understand how we can interact with API objects. We recognized many differences between Swift 3 and the previous versions of the programming language when interacting with APIs.

Now that you have learned some of the basics of the object-oriented paradigm, we are ready to start creating classes and instances in Swift 3, which is the topic of the next chapter.