Fundamentals of the Object-Oriented Model

Exam Tip: Remember that an "Operation" is the conceptual requirement (the "what"), while the "Method" is the actual implementation (the "how").

Encapsulation and Visibility

Encapsulation is the ability to hide an object's internal details—its attributes and methods—from the outside world. By denying direct access to the internal data structure, the object ensures the integrity of its state. Instead of changing data directly, external entities must send a message to invoke a method, which then validates the change.

To manage this, O-O models use visibility modifiers to control access:

• Public (+): Accessible from anywhere—inside the class, in subclasses, and from the outside world.
• Protected (#): Accessible only within the class itself and its derived (sub)classes.
• Private (-): Accessible only within the class that defines it; it is hidden from all other classes.

Inheritance and Generalization

One of the most powerful features of the O-O model is inheritance, which allows for code reusability. Inheritance creates a "is-a" relationship, where a specialized class inherits the attributes and behaviors of a more general class.

In a class hierarchy:

• The Superclass (or Parent) is the general class.
• The Subclass (or Child) is the specialized class.

This process is often described through generalization, where we group objects with common characteristics into a single superclass.

Types of Inheritance

• Single Level: A child inherits from one parent.
• Hierarchical: Multiple children inherit from the same single parent (e.g., Dog and Cat both inherit from Animal).
• Multilevel: A chain of inheritance (e.g., Grandparent $\rightarrow$ Parent $\rightarrow$ Child).
• Multiple: A single child inherits from two or more distinct parents.
• Hybrid: A combination of two or more of the above types.

Polymorphism

Polymorphism is the property that allows different objects to respond to the same message in different ways. While inheritance allows a subclass to share the structure of a superclass, polymorphism allows that subclass to provide its own unique implementation of a method. Together, inheritance and polymorphism are the primary drivers of code reusability and system flexibility.

Interfaces: The Contractual Approach

An interface is a special type of structure that specifies what a class must be able to do, without specifying how it does it. It acts as a contract. When a class "implements" an interface, it promises to provide the specific methods defined by that interface.

This separates the usage of an object from its implementation. For example, a "Driver" class can interact with any object that implements a "Drivable" interface, whether that object is a Car or a Boat, without needing to know the specific internal mechanics of each.

Key Distinction: Concrete inheritance describes what an object is (A Car is an Automobile), whereas an interface describes what an object can do (A Car implements Drivable).