Protocols in iOS Object-Oriented Programming

In case you’re new to coding and diving into the world of Swift, one of the thrilling and versatile ideas you’ll encounter is protocols. Protocols are a basic constructing block of Swift’s object-oriented programming (OOP) mannequin and may help you write cleaner, extra modular, and extra reusable code.

On this article, you’ll discover the ability of protocols and the right way to use them to create versatile, adaptable, and strong Swift apps. By the tip, you’ll have a stable understanding of protocols and be able to put them into follow in your individual initiatives. It’s time to get began!

What Are Protocols?

In Swift, a protocol is a blueprint that defines a set of properties, strategies, and different necessities. Courses, structs, and enums can then “conform” to a protocol, which implies they need to implement the protocol’s necessities.

Protocols are like a contract – they specify what a conforming sort should present however don’t really implement any of that performance themselves. This separation of interface and implementation is likely one of the key advantages of protocols.

Right here’s a easy instance of a protocol in Swift:

import Basis

protocol Nameable {
    var title: String { get set }
    func introduce()
}

struct Individual: Nameable {
    var title: String
    
    func introduce() {
        print("Hiya, my title is (title).")
    }
}

let tom = Individual(title: "Tom")
tom.introduce() // Prints "Hiya, my title is Tom."

On this instance, you outline a Nameable protocol that requires a title property, with each getter and setter, and an introduce technique. You then create a Individual struct that conforms to the Nameable protocol by implementing the required properties and strategies.

By utilizing a protocol, you’ve created a generic, reusable blueprint for any sort that must be “nameable.” This makes your code extra modular, versatile, and simpler to take care of.

Protocols and Inheritance

One highly effective function of protocols in Swift is their means to work seamlessly with inheritance. When a category inherits from one other class, it mechanically inherits all the properties and strategies of the superclass. However what if you wish to add extra necessities to a subclass?

That is the place protocols turn out to be useful. Check out an instance:

  
import Basis

protocol Automobile {
    var make: String { get }
    var mannequin: String { get }
    func drive()
}

class Automobile: Automobile {
    let make: String
    let mannequin: String
    
    init(make: String, mannequin: String) {
        self.make = make
        self.mannequin = mannequin
    }
    
    func drive() {
        print("Driving the (make) (mannequin).")
    }
}

class ElectricCar: Automobile, Chargeable {
    func cost() {
        print("Charging the (make) (mannequin).")
    }
}

protocol Chargeable {
    func cost()
}

On this instance, you will have a Automobile protocol that defines the essential properties and strategies of a car. The Automobile  class conforms to the Automobile protocol and offers the required implementations.

You then create a brand new ElectricCar  class that inherits from Automobile  and in addition conforms to a brand new Charcheable protocol. This allows you to add the cost()  technique to the ElectricCar class with out modifying the Automobile  class.

By combining inheritance and protocols, you’ve created a versatile and extensible class hierarchy that may simply accommodate new necessities and behaviors.

Placing it Into Observe

Now that you simply perceive protocols, it’s time to place them into follow with a pattern app. You’ll create a primary purchasing cart system that demonstrates the ability of protocols.

Open up a brand new Apple Playground and get began! In case you don’t have Apple Playgrounds, you’ll be able to obtain it right here: https://developer.apple.com/swift-playgrounds/ 

import Basis

protocol Merchandise {
  var title: String { get set }
  var worth: Double { get set }
}

// Bodily Merchandise Struct (conforms to Merchandise)
struct PhysicalItem: Merchandise {
  var title: String
  var worth: Double
  let weightInGrams: Int
}

// Digital Merchandise Struct (conforms to Merchandise)
struct DigitalItem: Merchandise {
  var title: String
  var worth: Double
  let downloadSize: String
}

// ShoppingCart Protocol
protocol ShoppingCart {
  var gadgets: [Item] { get set }
  mutating func addItem(_ merchandise: Merchandise)
  func calculateTotalPrice() -> Double
}


struct BasicCart: ShoppingCart {

  var gadgets: [Item] = []

mutating func addItem(_ merchandise: Merchandise) { 
    gadgets.append(merchandise)
  }

  func calculateTotalPrice() -> Double {
    var complete = 0.0
    for merchandise in gadgets {
      complete += merchandise.worth
    }
    return complete
  }
}

// Utilization Instance
var cart = BasicCart()

let milk = PhysicalItem(title: "Milk", worth: 2.99, weightInGrams: 946)
let e-book = DigitalItem(title: "Swift Programming Information", worth: 9.99, downloadSize: "10MB")

cart.addItem(milk)
cart.addItem(e-book)

let totalPrice = cart.calculateTotalPrice()
print("Whole worth: $(totalPrice)") // Prints "Whole worth: $12.98"

This instance demonstrates the right way to create a primary purchasing cart system in Swift utilizing protocols and structs. Right here’s a breakdown of the code:

Defining the Merchandise Protocol:

You begin by defining a protocol named Merchandise. This protocol acts as a blueprint for any merchandise that may be added to the purchasing cart. It specifies two properties that every one gadgets will need to have: title, a string, and worth, a double.

Creating Merchandise Structs:

Subsequent, you create two structs, PhysicalItem and DigitalItem, which conform to the Merchandise protocol. PhysicalItem represents a bodily product with an extra property, weightInGrams. DigitalItem represents a digital product with a downloadSize property. Each structs inherit the title and worth properties from the Merchandise protocol.

Designing the ShoppingCart Protocol:

The ShoppingCart protocol outlines the functionalities wanted to handle a group of things within the cart. It defines three properties and strategies:

• var gadgets: [Item] { get set }: This property shops an array of Merchandiseobjects, representing the gadgets within the cart.
• mutating func addItem(_ merchandise: Merchandise): This technique permits including an merchandise to the cart. The mutating key phrase signifies that this technique modifies the cart’s state by including an merchandise.
• func calculateTotalPrice() -> Double: This technique calculates the full worth of all gadgets within the cart based mostly on their particular person costs.

Implementing the BasicCart Struct:

The BasicCart struct implements the ShoppingCart protocol, offering the concrete performance for managing the cart.

• var gadgets: [Item] = []: This initializes an empty array to retailer the gadgets added to the cart.
• mutating func addItem(_ merchandise: Merchandise): This perform appends the supplied merchandise to the gadgets array, successfully including it to the cart.
• func calculateTotalPrice() -> Double: This perform iterates by the gadgets array, accumulates the costs of all gadgets, and returns the full worth.

Utilization Instance:

The code demonstrates the right way to use the BasicCart struct in follow. You first create a BasicCart occasion referred to as cart. Then, you create two merchandise objects: milk, a PhysicalItem, and e-book, a DigitalItem. You add each gadgets to the cart utilizing the addItem technique. Lastly, you name the calculateTotalPrice technique to get the full worth of all gadgets within the cart and print it to the console.