Swift Required Initializer

A required initializer is a class initializer marked with the required modifier, enforcing a strict compiler contract that every direct and indirect subclass must implement that specific initializer.

Syntax and Implementation

To designate an initializer as required, place the required keyword before the init declaration in the superclass. When a subclass implements this initializer, it must also use the required keyword to propagate the requirement down the inheritance hierarchy. When a subclass implements a superclass’s already-required initializer, the override modifier is omitted.

class BaseClass {
    var name: String
    
    required init(name: String) {
        self.name = name
    }
}

class SubClass: BaseClass {
    var age: Int
    
    // 'required' is mandatory. 'override' is omitted.
    required init(name: String) {
        self.age = 0
        super.init(name: name)
    }
}

Inheritance Rules

Subclasses do not always need to explicitly provide an implementation for a required initializer. If a subclass satisfies Swift’s rules for automatic initializer inheritance—specifically, by not defining any new designated initializers of its own—it will implicitly inherit the required initializer from its superclass.

import Foundation

class AnotherSubClass: BaseClass {
    // Inherits required init(name:) automatically 
    // because no new designated initializers are introduced.
    var id: UUID = UUID() 
}

Protocol Conformance

When a class conforms to a protocol that declares an initializer, the compiler mandates that the class implement that initializer with the required modifier. This guarantees that any future subclasses will also fulfill the protocol’s instantiation requirements.

protocol Describable {
    init(description: String)
}

class Item: Describable {
    var description: String
    
    // Must be 'required' to satisfy the protocol for all potential subclasses
    required init(description: String) {
        self.description = description
    }
}

The override and required Combination: If a subclass satisfies a protocol’s initializer requirement by overriding a non-required designated initializer from its superclass, both the required and override modifiers are mandatory.

class SuperItem {
    init(description: String) {
        // Non-required designated initializer
    }
}

class SubItem: SuperItem, Describable {
    var description: String
    
    // Both 'required' and 'override' are mandatory
    required override init(description: String) {
        self.description = description
        super.init(description: description)
    }
}

Exception for Final Classes: If a class is marked with the final modifier, it cannot be subclassed. Therefore, when a final class implements a protocol’s initializer, the required keyword is omitted because the inheritance chain is terminated.

final class FinalItem: Describable {
    var description: String
    
    // 'required' is omitted because the class is final
    init(description: String) {
        self.description = description
    }
}

Tired of Poor Swift Skills? Fix That With Deep Grasping!Learn More

Methods

Initializers

Closures

Type Declarations

Properties

Generics

Optional Binding

Patterns

Extensions

Error Handling

Attributes

Subscripts

Parameters

Constants & Variables

Conditionals

Loops

Collection Types

Basic Types

Numeric Types

Imports

Comments

Optional Operators

Arithmetic Operators

Overflow Operators

Assignment Operators

Bitwise Operators

Comparison Operators

Conditional Operators

Logical Operators

Range Operators

Type-Casting Operators

Swift Required Initializer

Syntax and Implementation

Inheritance Rules

Protocol Conformance

​Syntax and Implementation

​Inheritance Rules

​Protocol Conformance

Syntax and Implementation

Inheritance Rules

Protocol Conformance