Swift
Swift Classes
This chapter explores swift-classes , a fundamental building block for object-oriented programming. Classes allow developers to create custom types, encapsulate data, and define behavior. By mastering classes, you can design scalable and reusable components in Swift applications.
Chapter Goals
- Understand what classes are and their role in Swift programming.
- Learn how to define and instantiate classes.
- Explore advanced features like inheritance, methods, and initializers.
- Implement real-world examples using classes.
Key Characteristics of Swift Classes
- Reference Type: Instances are passed by reference.
- Encapsulation: Combine properties and methods into a single entity.
- Inheritance: Enable a class to inherit from another.
- Custom Initializers: Allow flexible object creation.
- Deinitializers: Perform cleanup tasks when an object is deallocated.
Basic Rules for Classes
- Use the class keyword to define a class.
- Classes can contain properties, methods, and initializers.
- Use init for initialization and deinit for cleanup.
- Support inheritance and method overriding.
Syntax Table
| Serial No | Feature | Syntax/Example | Description |
| 1 | Class Declaration | class ClassName { … } | Declares a new class. |
| 2 | Property Declaration | var propertyName: Type | Defines a property within a class. |
| 3 | Method Declaration | func methodName() { … } | Defines a function within a class. |
| 4 | Initializer | init(parameters) { … } | Sets up an object upon instantiation. |
| 5 | Inheritance | class SubClass: SuperClass { … } | Creates a class that inherits from another class. |
Syntax Explanation
1. Class Declaration
What is a Class Declaration?
A class declaration defines a new type that combines data and behavior.
Syntax
class Person {
var name: String
var age: Int
init(name: String, age: Int) {
self.name = name
self.age = age
}
func introduce() {
print(“Hello, my name is \(name) and I am \(age) years old.”)
}
}
Detailed Explanation
- Use the class keyword followed by the class name.
- Enclose properties and methods within curly braces ({}).
- Define an initializer to set up the class properties.
- Methods define the behavior of the class.
Example
let person = Person(name: “Alice”, age: 30)
person.introduce()
Example Explanation
- Creates a Person object with a name and age.
- Calls the introduce method to print the person’s details.
2. Property Declaration
What is a Property Declaration?
Properties store values within a class.
Syntax
var propertyName: Type
Detailed Explanation
- Properties can be variables (var) or constants (let).
- Store data specific to each class instance.
- Can have default values or be set during initialization.
Example
class Car {
var make: String
var model: String
var year: Int = 2024
init(make: String, model: String) {
self.make = make
self.model = model
}
}
let car = Car(make: “Tesla”, model: “Model S”)
print(“\(car.make) \(car.model), \(car.year)”)
Example Explanation
- Declares a Car class with three properties.
- Initializes the make and model while using a default value for year.
3. Method Declaration
What is a Method Declaration?
Methods define actions or behaviors for a class.
Syntax
func methodName() { … }
Detailed Explanation
- Methods are functions defined within a class.
- Access class properties using self (optional).
- Can modify instance properties or perform specific tasks.
Example
class Calculator {
func add(a: Int, b: Int) -> Int {
return a + b
}
}
let calculator = Calculator()
print(calculator.add(a: 5, b: 3))
Example Explanation
- Declares a Calculator class with an add method.
- Calls the add method to compute and print the sum.
4. Initializer
What is an Initializer?
An initializer sets up an object with initial values.
Syntax
init(parameters) { … }
Detailed Explanation
- Use init to define the initialization process.
- Assign values to properties using self.propertyName.
- Supports default parameter values and overloading.
Example
class Rectangle {
var width: Double
var height: Double
init(width: Double, height: Double) {
self.width = width
self.height = height
}
func area() -> Double {
return width * height
}
}
let rectangle = Rectangle(width: 10, height: 20)
print(rectangle.area())
Example Explanation
- Declares a Rectangle class with an initializer for width and height.
- Computes and prints the area using the area method.
5. Inheritance
What is Inheritance?
Inheritance allows a class to acquire the properties and methods of another class.
Syntax
class SubClass: SuperClass { … }
Detailed Explanation
- Use the : symbol to specify the parent class.
- The subclass inherits all non-private properties and methods of the parent class.
- Override methods to customize behavior.
Example
class Animal {
func sound() {
print(“Some generic animal sound”)
}
}
class Dog: Animal {
override func sound() {
print(“Bark”)
}
}
let dog = Dog()
dog.sound()
Example Explanation
- Defines an Animal class with a sound method.
- Creates a Dog subclass that overrides sound.
- Prints “Bark” when calling the sound method on a Dog instance.
Real-Life Project: Inventory Management System
Project Goal
Create an inventory management system to track products using classes.
Code for This Project
class Product {
var name: String
var price: Double
var quantity: Int
init(name: String, price: Double, quantity: Int) {
self.name = name
self.price = price
self.quantity = quantity
}
func totalValue() -> Double {
return price * Double(quantity)
}
}
class Inventory {
var products: [Product] = []
func addProduct(_ product: Product) {
products.append(product)
}
func displayInventory() {
for product in products {
print("\(product.name): $\(product.price), Quantity: \(product.quantity), Total: $\(product.totalValue())")
}
}
}
let inventory = Inventory()
let product1 = Product(name: "Laptop", price: 999.99, quantity: 5)
let product2 = Product(name: "Phone", price: 499.99, quantity: 10)
inventory.addProduct(product1)
inventory.addProduct(product2)
inventory.displayInventory()Steps
- Define a Product class with properties for name, price, and quantity.
- Create an Inventory class to manage multiple products.
- Implement methods to add products and display the inventory.
- Test the system with sample products.
Save and Run
Steps to Save and Run
- Write the code in your Swift IDE (e.g., Xcode).
- Save the file using Command + S (Mac) or the appropriate save command.
- Click “Run” or press Command + R to execute the program.
Benefits
- Demonstrates object-oriented design.
- Highlights encapsulation and method usage.
- Provides a practical application for classes in inventory management.
Best Practices
Why Use Classes?
- Encapsulate related data and behavior.
- Promote code reuse through inheritance.
- Simplify complex systems with modular design.
Key Recommendations
- Use meaningful names for classes and properties.
- Limit each class to a single responsibility.
- Avoid tight coupling between classes; use protocols for flexibility.
Example of Best Practices
class Employee {
var name: String
var role: String
init(name: String, role: String) {
self.name = name
self.role = role
}
func work() {
print(“\(name) is working as a \(role).”)
}
}
let employee = Employee(name: “John”, role: “Developer”)
employee.work()
Insights
Swift classes provide a robust framework for building reusable, scalable, and maintainable code. By leveraging object-oriented principles, developers can create efficient and organized applications.
Key Takeaways
- Classes encapsulate data and behavior into a single construct.
- Use initializers to set up objects and methods to define actions.
- Inheritance enables code reuse and extensibility in Swift.