# **๐ŸŽจ Exhibit: Object-Oriented Programming (OOP)** Object-Oriented Programming organizes software design around **data**, or **objects**, rather than functions and logic. An object is a self-contained unit that groups together variables (state) and methods (behavior). ## **๐Ÿ“ Architectural Foundations** OOP was designed to manage code complexity by modeling computer components like physical, modular biological units or hardware chips. ### **1\. Dynamic Dispatch Resolution** In object systems, method execution is resolved at runtime. Instead of calling a static function address directly, an object receives a message and determines which implementation to run: ![][image1]Where ![][image2] is the requested method selector, ![][image3] is the class of the receiving object, and ![][image4] is its superclass. This lookup process allows for **polymorphism**. ## **๐Ÿ”‘ Core Pillars of OOP** * **Encapsulation:** Hiding internal object details (private state) and exposing only what is necessary through a public interface (methods). This prevents external components from corrupting internal states. * **Abstraction:** Using simple class models to represent complex underlying mechanisms. * **Inheritance:** Establishing hierarchical relationships where child classes inherit properties and behaviors from parent classes (reusing code). * **Polymorphism:** The ability of different objects to respond to the same message in unique, specialized ways (e.g., both a Dog and a Cat class responding to a speak() message). ## **๐Ÿ›๏ธ Historical Museum Tour** Explore how OOP developed from a conceptual research experiment into the corporate enterprise standard: ### 1. The Pure Message Pioneer: [Smalltalk (1972)](../eras/The%20Structured%20Foundation%20%281970s%29/Smalltalk%20Booth.md) Developed at Xerox PARC, Smalltalk made "everything an object." It modeled software as an ecosystem of objects communicating via dynamic message passing. Arithmetic like 3 + 4 is actually sending the message + with the argument 4 to the integer object 3. ### 2. High-Performance Hybrid: [C++ (1983)](../eras/The%20Multi-Paradigm%20Dawn%20%281980s%29/C%2B%2B%20Booth.md) Bjarne Stroustrup created C++ ("C with Classes") to merge the object abstractions of Simula with the high-speed execution model of C. C++ introduced compile-time class blueprints and multiple inheritance while maintaining manual hardware-level memory speed. ### 3. Dynamic Runtime Bindings: [Objective-C (1984)](../eras/The%20Multi-Paradigm%20Dawn%20%281980s%29/Objective-C%20Booth.md) Objective-C integrated Smalltalkโ€™s dynamic messaging directly onto the standard C syntax engine. By executing method calls via objc_msgSend(), Objective-C deferred execution binding completely to runtime, making applications highly flexible. ### 4. Enterprise Class Hierarchies: [Java (1995)](../eras/The%20Web%20Boom%20%26%20Dynamic%20Runtimes%20%281990s%29/Java%20Booth.md) Java popularized enterprise OOP by removing manual pointers and mandating that every single instruction exist within a structured class hierarchy. It utilized single inheritance and interfaces to build incredibly predictable application models for corporations. ## **๐ŸŽจ Paradigm Showpiece: Polymorphic Dispatch** Let's look at how polymorphism allows a single execution call to adapt structurally to different target objects. ### **Example in C++ (Polymorphic Class Abstraction)** \#include \ \#include \ // Abstract Base Class class Instrument { public: virtual void play() const \= 0; // Pure virtual function virtual \~Instrument() {} // Safe RAII cleanup }; class Violin : public Instrument { public: void play() const override { std::cout \<\< "\[Violin\] Playing expressive, bowed strings..." \<\< std::endl; } }; class Synthesizer : public Instrument { public: void play() const override { std::cout \<\< "\[Synth\] Playing electronic wave oscillators..." \<\< std::endl; } }; int main() { // Collect polymorphic pointers to the base class interface std::vector\ orchestra; orchestra.push\_back(new Violin()); orchestra.push\_back(new Synthesizer()); // Execute same method selector, triggering different behaviors at runtime for (const auto\* instrument : orchestra) { instrument-\>play(); } // Dynamic cleanup for (auto\* instrument : orchestra) { delete instrument; } return 0; } Turn back to the [Functional Paradigm Guide](Functional%20Paradigm%20Guide.md) or continue with the [Low-Level Paradigm Guide](Low-Level%20Paradigm%20Guide.md). [image1]: [image2]: [image3]: [image4]: