Object Oriented Programming and Design Crash Course

Clarify what an object oriented object is, distinct from real world objects and classes, with car and parts examples. Emphasize adopting the correct object oriented mindset to improve programming skills.

Understand how a class is a blueprint for objects, defining their state and behavior and how to instantiate them, while objects live in memory as class-based instances.

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.

Identify a class's responsibility as the part of the system's requirements it implements. Name classes to clearly reflect that duty and avoid vague names and code smells.

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 how composition connects a fetch vendors use case to a server API and a settings manager, forming a composite object and revealing the complexities of object oriented design.

Discover how composition preserves the single responsibility principle by delegating file operations to a files helper, reusing responsibilities, and boosting readability and maintainability through focused collaborator objects.

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.

Explore how inheritance works in statically typed languages like Java and dynamically typed languages like Python, using abstract classes, interfaces, and duck typing to reveal implementation inheritance.

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

Question the belief that inheritance equals code reuse and its drawbacks. Choose composition, apply the single responsibility principle, and avoid god objects.

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.

Learn how object oriented design uses evolving best practices to create standalone abstractions, align names with business domain terminology, and deliver maintainable, extensible software that meets requirements.

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.