Summer’s over — what’s your move? Join Pro for 50% off using code [MAKEITHAPPEN](https://www.codecademy.com/checkout?periods=year&plan_id=proGoldAnnualV2&discountCode=MAKEITHAPPEN)


Classes

In the previous exercise, we’ve supplied our instances’ properties with default values. However, if we know that our class instances vary a lot from one to another, we can include an `init()` method for customization. The following syntax is used for an `init()` method:

```pseudo
class className {
  var property = value
  init (property: valueType) {
     self.property = property
  }
}
```

The `init()` method is special since it doesn't require the `func` keyword and gets called upon instance creation. Another unique feature is that the `init()` method uses the `self` keyword to reference itself.

Let's see the `init()` in action:

```swift
class Student {
  var name = ""
  var year = 0
  var gpa = 0.0
  var honors = false
  
  init(name: String, year: Int, gpa: Double, honors: Bool) {
    self.name = name
    self.year = year
    self.gpa = gpa
    self.honors = honors
  }
}
```

So now we can create an instance of the `Student` class and initialize its properties in one line:

```swift
var bart = Student(name: "Bart Simpson", year: 4, gpa: 0.0, honors: false)
```

Note that all properties must have arguments and the ordering of the params must match the ordering of the declared properties.


The Init Method

To refresh, a `class` is simply a template to create objects. The term "object" is often used to refer to an instance of a class. So for example, a building blueprint is a class and each house is an object, or an instance of the class.

In the previous example, we created a class to model students:

```swift
class Student {
  var name = ""
  var year = 0
  var gpa = 0.0
  var honors = false
}
```

With this blueprint, we can now start creating instances of `Student`. We can make hundreds or even thousands of them if we want to! Let's make an instance of `Student` to model the infamous [Ferris Bueller](https://www.imdb.com/title/tt0091042/).

The syntax for creating an instance:

```swift
var ferris = Student()
```

Here, we've created a single instance of `Student` and saved it to `ferris`. We can now access and edit the property values by using the dot syntax, `.property`.

```swift
ferris.name = "Ferris Bueller"
ferris.year = 12
ferris.gpa = 3.81
ferris.honors = false
```

And now we know how to get Ferris Bueller out of a class. 💨

Creating an Instance

So far, we’ve used several data types, including `Int`, `Double`, `String`, and `Bool`. We've even created our own "type" using `struct`s to make blueprints and templates for objects in our program.

Besides structures, Swift has another construct that also serves as a blueprint or template for an object, a class! A class also defines the characteristics and behaviors of an object. While they feel and behave very similarly, classes come with additional quirks that structures don't have:

- Inheritance enables one class to inherit the characteristics of another class.
- Classes are reference types while structures are value types.

Suppose a company called Hooli gives out ID badges to its employees. Somewhere down the line, the powers that be decide to have a variation of the badges made just for all the managers. 

So instead of creating the new badge template from scratch, we would use the employee badge template to create the manager badge template — that's inheritance! Because managers are still employees, but also have their own special security clearance.

We will explore these differences a bit more, but first, let's get classy with Swift!

Introduction to Classes

Woohoo! You've now added classes to your Swift toolbox. 🙌

With structures and classes being so darn similar, when do we use structures and when do we use classes? 

The rule of thumb is to always use `struct` to start, and change it to `class` if inheritance is needed or use class instances for their reference typing.

In this lesson, we covered:

- A class is another means of modeling real-life objects programmatically.
- How to create a class using the `class` keyword.
- Using the `init()` method allows us to provide an instance with specific values right off-the-bat during the creation of an instance.
- A class can inherit another class's properties and methods.
- When using inheritance, the subclass can use the `override` keyword to redeclare a method with the same name.
- Classes are reference types, any copied class that has its properties altered will affect the original class from which it was copied.

Review

Just like structures, we can use classes to model everyday objects. And the syntax looks awfully similar.

Here's the basic syntax for creating a class:

```pseudo
class Name {
  
}
```

The `class` keyword followed by a class name creates the class. By convention, the class name is capitalized. And just like structures, classes also contain both properties and methods.

Suppose we are writing a program for a school to keep track of all the students. Then we can create a blueprint for this type of data by using a class.

Here's a `Student` class that models a student:

```swift
class Student {
  var name: String
  var year: Int
  var gpa: Double
  var honors: Bool
}
```

The `Student` class has four properties:

- `.name` of the type `String`
- `.year` of the type `Int`
- `.gpa` of the type `Double`
- `.honors` of the type `Bool`

We can also use Swift's default property values so that the `Student` class can have predefined values inside the class:

```swift
class Student {
  var name = ""
  var year = 0
  var gpa = 0.0
  var honors = false
}
```

Now when we create a new instance of `Student`, that instance's `.name` will be an empty string `""`, its `.year` will be `0`, and so on.

Creating a Class

To continue the conversation on inheritance, a subclass can provide its own custom implementation of a property or method that is inherited from a superclass. This is known as _overriding_.

To override a method, we can redeclare it in the subclass and add the `override` keyword to let the compiler know that we aren't accidentally creating a method with the same name as the one in the parent class.

```pseudo
override func name(parameter) {

}
```

So here's the `BankAccount` class again:

```swift
class BankAccount {

  var balance = 0.0

  func deposit(amount: Double) {
    balance += amount
  }

  func withdraw(amount: Double) {
    balance -= amount
  }

}
```

Suppose we want a new `SavingsAccount` class and we want to override the `.withdraw()` method from its superclass `BankAccount`:

```swift
class SavingsAccount: BankAccount {

  var interest = 0.0
  var numWithdraw = 0

  func addInterest() {
    let interest = balance * 0.01
    self.deposit(amount: interest)
  }

  override func withdraw(amount: Double) {
    balance -= amount
    numWithdraw += 1
  }

}
```

Here, the new `.withdraw()` method not only subtracts `amount` from `balance`, but it also increments `numWithdraw`.


Overriding Methods

Another one of the biggest main distinctions between structures and classes is that:

- Structures are value types
- Classes are reference types

A value type is a type whose value is copied when it's assigned to a variable or constant, or when it's passed to a function. For example, if a company asks for your driver's license, you wouldn't give them your driver's license to keep - you'd make a copy of it or jot down the info and leave that with them. Your original driver's license remains untouched. All the basic types in Swift, `Int`, `Double`, `Bool`, `String`, arrays, and dictionaries, are value types.

Unlike value types, _reference types_ are not copied when they are assigned to a variable or constant, or when they are passed to a function. Rather than a copy, a reference to the same existing instance is used.

Here’s an example. Suppose we have an instance of a `Restaurant` class called `krustyKrab`:

```swift
var krustyKrab = Restaurant()

krustyKrab.name = "The Krusty Krab"
krustyKrab.type = ["Seafood", "Burgers"]
krustyKrab.rating = 2.4
krustyKrab.delivery = true
```

Suppose the owner Eugene decides to franchise the restaurant and there's a new one called `krustyKrab2`. If we copy the instance and assign one of the properties a new value:

```swift
var krustyKrab2 = krustyKrab
krustyKrab2.rating = 4.1

print(krustyKrab.rating)
// Prints: 4.1
print(krustyKrab2.rating) 
// Prints: 4.1
```

Notice how that even though we are changing `krustyKrab2`'s property, `krustyKrab`'s property also changed. That's why we have to be careful when changing the property values of a class instance. 

For more reading, take a look at the [Swift documentation](https://docs.swift.org/swift-book/LanguageGuide/ClassesAndStructures.html#ID89).

Classes are Reference Types

In the previous exercises, we've defined a class, created instances, and added an `init()` method. But all these concepts were the same in structures. So now we have to ask, "how are classes different from structures?". 

When we define a class, it can _inherit_, or take on, another class's properties and methods. This is an additional capability that structures don't offer. Moreover, inheritance is a fundamental behavior that differentiates classes from other types in Swift.

When one class inherits from another:

- The new inheriting class is known as a _subclass_.
- The class it inherits from is known as its _superclass_.

To create a class that inherits from another, we put the name of the class we're inheriting from (superclass) after the name of the class we're creating (subclass), like so:

```pseudo
class Subclass: Superclass {

}
```

So suppose we have a `BankAccount` class that looks like:

```swift
class BankAccount {
  var balance = 0.0

  func deposit(amount: Double) {
    balance += amount
  }

  func withdraw(amount: Double) {
    balance -= amount
  }
}
```

It has:

- a `.balance` property that stores the amount of money
- a `.deposit()` method that adds to the balance
- a `.withdraw()` method that takes from the balance

And we want a new `SavingsAccount` class that inherits from `BankAccount`:

```swift
class SavingsAccount: BankAccount {
  var interest = 0.0

  func addInterest() {
    let interest = balance * 0.005
    self.deposit(amount: interest)
  }
}
```

Here, the new `SavingsAccount` class (subclass) automatically gains all of the characteristics of `BankAccount` class (superclass), such as its `.balance` property and its `.deposit()` and `.withdraw()` methods. 

In addition, the `SavingsAccount` class defines the following:

- a `.interest` property that stores the interest rate
- a `.addInterest()` method that deposits the interest

And only `SavingsAccount` instances will have these.