Before we wrap up and talk about everything we've covered so

far it's important to address one point.

We learned of two ways we can encapsulate data, structs and classes.

When should we use either one?

A simple rule for now is to use structs to represent simple values as mentioned.

A coordinate point is just a set of values.

It doesn't really have an identity.

Classes, on the other hand,

are really good at representing more than just values.

Right now, it's hard to make that distinction since we just learned about

structs and classes to begin with, but honestly, really, don't worry about it.

We're going to revisit this topic again several times

until we have a good understanding of the differences between the two.

Now that we've seen two of the main types of objects we'll be working with in Swift,

let's go over the syntax and

concepts one last time before we take a code challenge to wrap up the course.

We have two main objects, structs and classes.

The syntax for creating either one is pretty similar.

We first start with a keyword that denotes what kind of object we want to create.

If it's a struct, we use the struct keyword, class for a class.

Both objects can contain stored properties.

In its simplest form, a stored property is a constant or a variable

that is stored as part of an instance of a particular class or structure.

We can make our stored properties mutable using the keyword var or

immutable using let.

Stored properties can also take default values as part of the class or

struct definition.

Using this blueprint of a class or

a struct definition, we can create an instance to use.

Creating an instance involves giving our stored properties initial values, and

we do this through a process called initialization.

Structs automatically get member wise initializers for stored properties, but

with classes, we need to define an init method.

An init method is simply a special instance method

that can take parameters like any function.

Inside the init method, we can set or

modify the initial values for any stored properties.

Both structs and classes can contain methods that we call on an instance.

These are known as instance methods and are written just like we write a function

except they're contained within the object definition and scope to it.

We access both stored properties and

instance methods by using dot notation with an instance.

All this is common between the two types of objects.

Here's where things start to diverge.

Classes support a mechanism called inheritance

where one class can be based off another and use the same implementation.

This leads to great code reuse and

allows us to extend objects in ways that narrowly scope their function.

For example, we don't need to build this one giant automobile class that has

the properties and methods of trains, buses, trucks, cars, motorbikes and so on.

Instead we can create a base vehicle class and then subclass that to create

more specific types, like bus, by adding properties and overriding methods.

To subclass a base class and create a new type, we declare a class like normal and

then add a colon and the name of the class we're inheriting from.

When we inherit from a superclass, we need to ensure that all the stored properties,

that is both for the subclass and

the superclass, are initialized when creating an instance.

We can create a new init method to do this if we want, but if we want to use

an initializer from the superclass like we did when we wrote the code,

we can simply override the init method and modify and set our values in there.

For now, there's a simple rule we're going to follow.

First, we provide values for the stored properties of the subclass.

Once this is sorted we'll call super init and

initialize any properties in the superclass.

The second main difference is that a struct is a value type

while a class is a reference type.

When you assign an instance of a struct to another variable or

constant, Swift copies the underlying values, creates a new instance, and

assigns it to the new constant or variable.

In contrast, when you assign an instance of a class to another constant or

variable, you are pointing to that exact same instance.

Any changes you make through one variable changes the original instance.

And that was a very quick high level run through on everything we've learned.

Don't worry, though, you'll have plenty of opportunities to put

all this into good use in the upcoming courses.

Now let's wrap this all up with a quiz and

a code challenge to see how well you know the material.

Remember, there are plenty of links included with the videos.

Make sure you go through this stuff,

because it will really help cement your knowledge.

Enjoy coding, and I will see you in the next course.