Classes in Swift are a core part of object-oriented programming (OOP). Unlike structs, which are value types, classes are reference types, meaning they are passed by reference, not by copying. Classes also support powerful features like inheritance, polymorphism, and encapsulation, making them ideal for modeling more complex data and behavior.
In this article, we’ll explore everything you need to know about classes in Swift—how to define them, work with properties and methods, leverage inheritance, and understand the key differences between classes and structs. By the end, you’ll have a solid understanding of how to use classes effectively to design robust and flexible Swift applications.
What is a Class?
A class in Swift is a blueprint for creating objects. Classes can have properties (which store data) and methods (which define behavior). Unlike structs, classes are reference types, meaning that when you assign or pass a class instance, you’re working with a reference to the same object, not a copy of the data.
Here’s the basic syntax for defining a class:
class Car {
var make: String
var model: String
var year: Int
init(make: String, model: String, year: Int) {
self.make = make
self.model = model
self.year = year
}
func start() {
print("\(make) \(model) is starting.")
}
}In this example, Car is a class with three properties (make, model, and year) and a method (start) that prints a message when the car starts.
Creating Instances of Classes
Once you define a class, you can create instances (objects) of that class by using the initializer method.
Example 1: Creating an Instance of a Class
let myCar = Car(make: "Toyota", model: "Camry", year: 2020)
myCar.start() // Output: Toyota Camry is starting.In this example, we create an instance of the Car class by providing values for the make, model, and year properties. The start() method is then called on the instance.
Reference Types: Classes vs. Structs
Classes in Swift are reference types, which means that when you assign a class instance to another variable, you’re assigning a reference to the same object, not a copy of the data. This is in contrast to structs, which are value types and are copied when passed or assigned.
Example 2: Classes as Reference Types
class Person {
var name: String
init(name: String) {
self.name = name
}
}
let person1 = Person(name: "Alice")
let person2 = person1 // person2 is a reference to the same instance as person1
person2.name = "Bob"
print(person1.name) // Output: Bob
print(person2.name) // Output: BobIn this example, both person1 and person2 refer to the same object in memory. Changing the name property of person2 also changes it for person1 because they share the same reference.
Properties in Classes
Classes can have both stored properties and computed properties. Stored properties hold constant or variable values, while computed properties dynamically calculate values based on other properties.
Example 3: Stored and Computed Properties
class Rectangle {
var width: Double
var height: Double
var area: Double {
return width * height
}
init(width: Double, height: Double) {
self.width = width
self.height = height
}
}
let rectangle = Rectangle(width: 10.0, height: 5.0)
print("Area: \(rectangle.area)") // Output: Area: 50.0In this example, the Rectangle class has stored properties for width and height and a computed property area, which calculates the area of the rectangle.
Methods in Classes
Classes can define methods that operate on the data within the class. These methods can modify properties and define behavior for the objects created from the class.
Example 4: Methods in a Class
class BankAccount {
var balance: Double
init(balance: Double) {
self.balance = balance
}
func deposit(amount: Double) {
balance += amount
print("Deposited $\(amount). New balance: $\(balance).")
}
func withdraw(amount: Double) {
if amount <= balance {
balance -= amount
print("Withdrew $\(amount). New balance: $\(balance).")
} else {
print("Insufficient funds.")
}
}
}
let account = BankAccount(balance: 100.0)
account.deposit(amount: 50.0)
account.withdraw(amount: 30.0)In this example, the BankAccount class defines methods for depositing and withdrawing money from a bank account.
Initializers in Classes
Classes can define initializers that set up the initial state of an instance. Swift provides a default initializer if all properties are initialized, but you can create your own custom initializers to customize the setup process.
Example 5: Custom Initializer in a Class
class Book {
var title: String
var author: String
var pages: Int
init(title: String, author: String, pages: Int) {
self.title = title
self.author = author
self.pages = pages
}
func description() -> String {
return "\(title) by \(author), \(pages) pages"
}
}
let book = Book(title: "1984", author: "George Orwell", pages: 328)
print(book.description()) // Output: 1984 by George Orwell, 328 pagesIn this example, we define a custom initializer that sets the title, author, and number of pages when creating a Book instance.
Inheritance in Classes
One of the key features of classes in Swift is inheritance. Inheritance allows you to create a new class that inherits the properties and methods of an existing class. The new class, called a subclass, can also add new properties and methods or override existing ones.
Example 6: Inheritance in Classes
class Vehicle {
var speed: Int
init(speed: Int) {
self.speed = speed
}
func describe() {
print("Traveling at \(speed) mph.")
}
}
class Car: Vehicle {
var make: String
var model: String
init(make: String, model: String, speed: Int) {
self.make = make
self.model = model
super.init(speed: speed) // Call the superclass initializer
}
override func describe() {
print("\(make) \(model) is traveling at \(speed) mph.")
}
}
let myCar = Car(make: "Tesla", model: "Model 3", speed: 60)
myCar.describe() // Output: Tesla Model 3 is traveling at 60 mph.In this example, Car inherits from Vehicle. The Car class adds new properties (make and model) and overrides the describe() method to provide a custom description.
Polymorphism and Method Overriding
Polymorphism allows you to treat a subclass instance as if it were an instance of its superclass. This is useful when you want to write code that works with objects of different types but shares a common superclass.
Example 7: Polymorphism with Inheritance
class Animal {
func makeSound() {
print("Some generic animal sound")
}
}
class Dog: Animal {
override func makeSound() {
print("Bark")
}
}
class Cat: Animal {
override func makeSound() {
print("Meow")
}
}
let animals: [Animal] = [Dog(), Cat(), Animal()]
for animal in animals {
animal.makeSound()
}
// Output:
// Bark
// Meow
// Some generic animal soundIn this example, the Animal class defines a makeSound() method, which is overridden by the Dog and Cat subclasses. The animals array contains instances of different types, but since they all share the same superclass (Animal), the same method can be called on each instance.
Reference Counting and Memory Management
Classes in Swift are reference types, which means they are managed by automatic reference counting (ARC). ARC tracks the number of references to each class instance and automatically deallocates the instance when it is no longer needed.
Example 8: Reference Counting with Classes
class Person {
var name: String
init(name: String) {
self.name = name
print("\(name) is being initialized.")
}
deinit {
print("\(name) is being deinitialized.")
}
}
var person1: Person? = Person(name: "Alice")
var person2: Person? = person1 // person2 is another reference to the same instance
person1 = nil // The instance is still alive because person2 holds a reference
person2 = nil // Now the instance is deallocatedIn this example, the Person class includes a deinit method, which is
called when the instance is deallocated. The object remains in memory as long as there is at least one reference to it.
Real-World Example: Modeling a Smart Home Device
Let’s use what we’ve learned to model a smart home device using a class. We’ll define properties for the device’s name and status and add methods to turn the device on and off.
class SmartDevice {
var name: String
var isOn: Bool
init(name: String, isOn: Bool = false) {
self.name = name
self.isOn = isOn
}
func turnOn() {
if !isOn {
isOn = true
print("\(name) is now ON.")
} else {
print("\(name) is already ON.")
}
}
func turnOff() {
if isOn {
isOn = false
print("\(name) is now OFF.")
} else {
print("\(name) is already OFF.")
}
}
}
let smartLight = SmartDevice(name: "Living Room Light")
smartLight.turnOn() // Output: Living Room Light is now ON.
smartLight.turnOff() // Output: Living Room Light is now OFF.In this real-world example, the SmartDevice class represents a smart home device that can be turned on or off. We define methods to control the device’s state and ensure that the status is updated correctly.
Best Practices for Using Classes
- Use classes for reference semantics: If you need shared state or reference behavior (where changes to one instance affect all references to it), use classes.
- Leverage inheritance: Use inheritance to create hierarchies of related classes. Subclasses can inherit behavior and properties from their superclass while adding their own functionality.
- Override methods carefully: When overriding methods in a subclass, make sure to call the superclass’s method where appropriate, using
super. - Manage memory with ARC: Be mindful of strong references and potential retain cycles in classes. Swift automatically handles memory with ARC, but it’s important to avoid strong reference cycles by using
weakorunownedreferences where necessary. - Use deinitializers for cleanup: If your class needs to perform cleanup tasks when it is deallocated, use the
deinitmethod to handle the cleanup.
Conclusion
Classes in Swift provide a flexible and powerful way to model complex data and behavior, thanks to their support for reference types, inheritance, and polymorphism. Whether you’re building a hierarchy of related types or managing shared state across multiple parts of your application, classes are an essential tool for Swift developers.
In this article, we covered:
- Defining classes and creating instances with properties and methods.
- Reference types and how class instances are passed by reference, not copied.
- Using inheritance to create subclass hierarchies and extend class functionality.
- Polymorphism and method overriding to work with subclasses in a dynamic way.
- Memory management with ARC and how Swift automatically handles class deallocation.
In the next article, we’ll dive into protocols in Swift—how to define interfaces and create reusable, flexible code through protocol-oriented programming.
Happy coding!
