Lectures

We’ll go over the basic inheritance rules in Kotlin: why classes and members are final by default, how to explicitly allow extension with open, how the : Base (...) syntax works with a mandatory base-class constructor call, what limitations hierarchies have (one base class, data class nuances), and which typical mistakes beginners run into most often.

We break down why Kotlin requires explicit overriding via open and override, how to correctly override methods and properties ( open fun, open val/ var), why the val → var trick is allowed, what final override means, and how the protected visibility modifier helps give subclasses access to internal details without turning your API into a “showcase of the internal kitchen”.

We break down how to correctly extend behavior when inheriting in Kotlin: when to call super inside override, how to reuse base logic in methods and property getters, and why the initialization order ( init blocks and properties) affects program correctness. We also discuss the danger of calling open members from constructors/initialization and show safe alternatives.

We break down polymorphism in Kotlin through a base type and dynamic behavior: how the open + override combo works, why a variable of type Base can store an object of Child, and how this helps avoid the explosion of when/ is. In practice, we will assemble a report as a list List<ReportLine> with a single method render() and print it with one loop.

We break down two Kotlin mechanisms that sound similar but are fundamentally different: overloading (overload—selection by parameters at compile time) and overriding (override—selection of an implementation at runtime). Using examples with open/ override and polymorphism, we show the main trap: “meant to override—accidentally overloaded”, and we also reinforce the differences with a table and a list of common mistakes.