Object Oriented Programming and Design Crash Course

learn how an object stores its private state, such as venue and visit history, and how its methods implicitly operate on that state, illustrating encapsulation in object oriented programming.

Master the single responsibility principle, which states a class should have only one responsibility and one reason to change, avoiding god classes and tangled code.

Object oriented objects are runtime containers for state and behavior, not real-world mappings. They arise from a class blueprint, emphasize encapsulation, and pursue single responsibility aligned with system requirements.

Explore why composition in object oriented programming creates complex dependency trees and life cycle management challenges, illustrated by a ping server use case with global objects.

Master dependency injection to manage long object graphs and lifecycles by centralizing construction in a composition route, with global and non-global objects reused through get methods.

Explore how composition uses references to other objects to implement behavior, and how dependency injection centralizes construction in a composition root to manage complex collaborations.

Explore the concept of inheritance in object oriented programming, using vehicle, car, and tax calculator examples to show how subclasses extend superclasses and customize methods.

Inheritance enables runtime class level polymorphism, letting objects with a common interface interchangeably implement different behaviors, as shown by tax calculators and Android activities.

Explore how inheritance is powerful yet fragile, and how composition provides a safe code reuse alternative, with insights from Effective Java and the Liskov substitution principle.

Master inheritance's role in enabling runtime polymorphism and semantic is-a relationships, while avoiding misuse for code reuse and preferring composition in Android framework contexts.

Contrast object oriented programming with object oriented design to reveal how composition, inheritance, and the single responsibility principle guide optimal use of object oriented languages.

Explore how object oriented design tackles the large code base problem by breaking complex systems into isolated, manageable parts and establishing clear boundaries for safer maintenance.

Understand abstraction as a wrapper that hides irrelevant details and exposes key properties, from statements to objects and modules, enabling clean interfaces for clients.

Adopt a shared ubiquitous language to improve naming in object oriented design. Align terms with domain experts, evolve names, and verify terminology to enhance readability and maintainability.

Explore how objects expose behavior and encapsulate data, while data structures expose data and lack behavior, and learn why separating them ensures clean, maintainable code.

Learn to distinguish uniquely identifiable entities and their thread of identity, and compare real world IDs, auto-increment keys, and UUIDs for safe tracking over time.

Explore what design patterns are and why they matter for object-oriented software, referencing the GOF book and the 80 over 20 rule for a focused set of patterns.

Explore the observer design pattern (publish-subscribe) where an observable notifies observers via a common interface using register and unregister, with on state change notifications and practical variations.

Learn how the facade design pattern simplifies complex subsystems by providing a single proxy interface that hides internal details, decouples clients, and streamlines collaboration and refactoring.

Learn the strategy design pattern: a family of classes with a common interface that encapsulate alternative algorithm implementations, enabling runtime selection, easier maintenance, and scalable plugin-like architectures.

Examine the singleton design pattern, its single global instance and getInstance access, and its drawbacks like hidden dependencies and global static state. Compare with dependency injection as a safer alternative.

Explore design patterns as standard, reusable source code solutions that create a ubiquitous technical language across applications, covering observer, facade, and strategy, and discuss benefits, drawbacks, and open closed principle.

Summarize core object oriented programming and design concepts, from objects as containers of state to single responsibility, dependency injection, and design patterns.