Lectures

We break down encapsulation in Kotlin through visibility control: why public by default is an “open door”, how private protects state and invariants, and where internal is appropriate (access within a module). Using Expense and ExpenseBook as examples, we show why you shouldn’t expose a MutableList, how to return a safe List snapshot, and how to validate data correctness via require ( ).

We break down why a property in Kotlin is a mini API: reading goes through get(), writing — through set(value). We learn how to “open” reads and “close” writes with private set, how to make computed properties (display properties) without storage, and how to work correctly with a backing field via field. Separately: validation/normalization in the setter ( require(...), trim()) and common mistakes (recursion in a setter, “expensive” computed properties, scattered validation).

We break down when it makes sense to use lateinit in Kotlin: how to declare non-null properties without initialization, what limitations exist ( val and primitives), what happens on early access, and how to design “two-stage readiness” via init(...) + check(...)/ require(...). We reinforce it with a practical example of a console session BudgetBuddySession.

We break down the delegated property val x by lazy { ... }: when exactly the block is executed, what and how gets cached, how lazy differs from a computed property via get ( ) and from lateinit, and what pitfalls appear due to stale cache, side effects, and thread-safety nuances.

We break down how to use a delegated property in Kotlin via by and the ready-made delegate Delegates.observable: when the handler is called (after assignment), what parameters it receives ( old/ new and property metadata), how not to break encapsulation with private set, and where this approach is especially convenient—logging, a “dirty” flag, a change counter. At the end—common mistakes: recursion in the handler, trying to validate “after the write”, and noisy logging.