Failable Initializer / required init

struct / class TypeName {
    // Failable initializer (returns an Optional)
    init?(parameter: Type) {
        guard condition else { return nil }  // Return nil on failure
        // Initialization code
    }

    // Implicitly unwrapped failable initializer (crashes on failure)
    init!(parameter: Type) {
        // ...
    }

    // Required initializer (must be implemented in all subclasses)
    required init(parameter: Type) {
        // ...
    }

    // Convenience initializer (classes only)
    convenience init(shorthandParameter: Type) {
        self.init(fullParameter: ...)  // Calls the designated initializer
    }
}

// A struct with a failable initializer
struct Temperature {
    let celsius: Double

    // Temperatures below absolute zero are not allowed
    init?(celsius: Double) {
        guard celsius >= -273.15 else {
            return nil
        }
        self.celsius = celsius
    }
}

// Success case
if let temp = Temperature(celsius: 25.0) {
    print("Temperature: \(temp.celsius)°C")
}

// Failure case
if Temperature(celsius: -300.0) == nil {
    print("Invalid temperature")
}

// Using required and convenience in a class
class Vehicle {
    var name: String
    var speed: Int

    // Designated initializer
    init(name: String, speed: Int) {
        self.name = name
        self.speed = speed
    }

    // Convenience initializer (calls the designated initializer)
    convenience init(name: String) {
        self.init(name: name, speed: 60)
    }

    // Must be implemented in all subclasses
    required init(json: [String: Any]) {
        self.name = json["name"] as? String ?? "Unknown"
        self.speed = json["speed"] as? Int ?? 0
    }
}

class Car: Vehicle {
    required init(json: [String: Any]) {
        super.init(json: json)
    }
}

let bike = Vehicle(name: "Bicycle")
print("\(bike.name): \(bike.speed)km/h")

let car = Car(json: ["name": "Sports Car", "speed": 200])
print("\(car.name): \(car.speed)km/h")

A failable initializer (init?) returns an Optional. If initialization fails, it returns nil and no instance is created. The init(rawValue:) initializer on enums also uses this mechanism.

Convenience initializers are available in classes only. They must always call a designated initializer of the same class. If a subclass defines its own initializers, the parent class's initializers are not automatically inherited. You must explicitly implement the parent's initializers if you want to use them.

For the basics of classes, see class basics / init() / deinit().