Swift: Inheritance

• Classes can inherit methods, properties, and characteristics from other classes.
• The inheriting class is known as a subclass.
• The class being inherited from is known as a superclass.
• Inheritance differentiates classes from other Swift types.
• Subclasses can access methods, properties, and subscripts of their superclass.
• Subclasses can provide overriding versions of these to change their behavior.
• Swift checks overrides to ensure they match superclass definitions.
• Classes can add property observers to inherited properties.
• Property observers can be added to any property, stored or computed.

Defining a Base Class

• A base class doesn't inherit from another class.
• The example Vehicle class has a stored property currentSpeed (default 0.0).
• The currentSpeed has a Double type.
• Vehicle class has a read-only computed String property called description.
• description creates a description of the vehicle using currentSpeed.
• Vehicle also defines a makeNoise() method (does nothing in the base class).

Creating a Vehicle Instance

• Use initializer syntax: Vehicle()
• Example: let someVehicle = Vehicle()
• Access the description property: someVehicle.description

Subclassing

• Subclassing creates a new class based on an existing one.
• Subclasses inherit and refine characteristics from the existing class.
• Indicate inheritance with a colon: class SomeSubclass: SomeSuperclass
• Example: class Bicycle: Vehicle
• Bicycle inherits currentSpeed, description, and makeNoise() from Vehicle.
• Bicycle defines a new stored property hasBasket (default false, type Bool).
• Inherited currentSpeed can be modified: bicycle.currentSpeed = 15.0
• Inherited description can be accessed: bicycle.description
• Subclasses can themselves be subclassed.
• Example: class Tandem: Bicycle
• Tandem inherits from Bicycle, which inherits from Vehicle.
• Tandem adds a new stored property currentNumberOfPassengers (default 0).
• Instances of Tandem can use new and inherited properties.

Overriding

• Overriding provides a custom implementation for inherited members.
• Use the override keyword to indicate an intended override.
• The override keyword ensures that superclass have the same declaration of the one provided for the override.
• The Swift compiler checks that overrides match superclass declarations.

Accessing Superclass Members

• Use the super prefix to access the superclass version of a member.
• super.someMethod() calls the superclass's someMethod().
• super.someProperty accesses the superclass's someProperty.
• super[someIndex] accesses the superclass's subscript.

Overriding Methods

• Subclasses can override instance or type methods.
• Example: Train subclass overrides makeNoise():

  class Train: Vehicle {
      override func makeNoise() {
          print("Choo Choo")
      }
  }
  

Overriding Properties

• Subclasses can override property getters, setters, and add property observers.

Overriding Property Getters and Setters

• You can override any inherited property, stored or computed.
• Must state the name and type of the overridden property.
• Read-only properties can be presented as read-write, but not vice versa.
• Example: Car subclass overrides description:

  class Car: Vehicle {
      var gear = 1
      override var description: String {
          return super.description + " in gear \(gear)"
      }
  }
  

• The Car class's description calls super.description and adds gear information.

Overriding Property Observers

• Property overriding can add property observers to inherited properties.
• Allows notification when an inherited property's value changes.
• Example: AutomaticCar subclass has a didSet observer on currentSpeed:

  class AutomaticCar: Car {
      override var currentSpeed: Double {
          didSet {
              gear = Int(currentSpeed / 10.0) + 1
          }
      }
  }
  

• The didSet observer updates the gear based on currentSpeed.

Preventing Overrides

• Mark a member as final to prevent overriding.
• Use final var, final func, final class func, and final subscript.
• Attempting to override a final member results in a compile-time error.
• An entire class can be marked as final (final class).
• Attempting to subclass a final class results in a compile-time error.