Object-Oriented Programming

The problem OOP solves and the vocabulary you need.

• Procedural versus object-oriented thinking
• Classes, objects and instances
• State and behaviour
• The four pillars at a glance
• Modelling a real-world example

• What is object-oriented programming?
• Classes: the blueprint of objects
• Classes, Instances and the self Parameter

Creating objects that start in a valid state.

• Constructors and initialisation
• Default and parameterised constructors
• this and self
• Constructor overloading and chaining
• Copy constructors
• Tracing object creation

• What is a constructor?
• Constructors with parameters
• Constructors and State Initialization with __init__

Hiding data and exposing a safe interface.

• Access modifiers and naming conventions
• Getters, setters and properties
• Validation inside setters
• Immutability
• Packages and modules
• Designing a small public interface

• Why encapsulation?
• Getters and setters
• The @property Decorator and Setters

Members that belong to the class, and values that cannot change.

• Instance versus class members
• Static variables and methods
• Class methods and static methods in Python
• Constants and final
• Static initialisation
• When not to use static

• Instance members and static members
• Static variables
• Instance Methods and self

Reusing and extending classes.

• Is-a relationships
• extends and super
• Method overriding
• Constructor order in inheritance
• Multilevel and multiple inheritance
• Method resolution order in Python
• Problems with deep hierarchies

• extends: parent and child classes
• Multilevel and hierarchical inheritance
• Single Inheritance and Method Overriding
• The super() Proxy and Method Resolution Order (MRO)

One interface, many behaviours.

• Compile-time and run-time polymorphism
• Method overloading versus overriding
• Dynamic dispatch
• Upcasting and downcasting
• instanceof and type checks
• Duck typing in Python

• What is polymorphism?
• Method overriding and its rules
• Downcasting and ClassCastException
• Polymorphism and Duck Typing

Describing what something does without saying how.

• Abstract classes and abstract methods
• Interfaces and default methods
• Abstract class versus interface
• Abstract base classes in Python
• Programming to an interface
• Enums

• Why abstraction?
• Abstract classes and abstract methods
• Built-in enum methods: values(), name(), valueOf(), ordinal()

How objects work together.

• Association, aggregation and composition
• Has-a versus is-a
• Objects inside objects
• Mixins in Python
• Favour composition over inheritance
• Dependency and coupling

• HAS-A vs IS-A
• Association: objects that work together
• Has-a versus Is-a: Why Prefer Composition
• Mixins and When Not to Use Inheritance

The methods every object has, and what copying really means.

• toString and __str__
• equals, hashCode and __eq__
• == versus equals
• References and aliases
• Shallow and deep copy
• Special methods and dataclasses in Python

• The Object class: every class's parent
• == compares references
• Shallow copy vs deep copy
• Equality and Hashing: __eq__ and __hash__

Reporting errors and writing reusable typed code.

• Exception classes and hierarchies
• Custom exceptions
• Checked versus unchecked exceptions
• Generic classes and methods
• Type hints in Python

• What is an exception?
• Handle an exception with try and catch
• The try and except Blocks

Guidelines and patterns for maintainable designs.

• Single responsibility
• Open-closed principle
• Liskov substitution
• Interface segregation
• Dependency inversion
• Factory, singleton, strategy, observer and decorator
• UML class diagrams

Covered in 1:1 mentoring sessions

Designing small systems from scratch.

• Requirements to classes
• CRC cards and class diagrams
• Implementing the design
• Testing the classes
• Explaining your design choices

• Bank Account Manager
• Employee Role Hierarchy
• Build a Library Management System