Inheritance: Establishes an IS-A relationship, allowing subclasses to inherit properties and behaviors. Polymorphism: Allows objects of different classes to be treated as objects of a common type.

Overriding: Subclass provides a specific implementation of a method already defined in its superclass. Overloading: Defining multiple methods in the same class with the same name but different parameters.

Superclass: A general class that other classes inherit from. Subclass: A specialized class that inherits properties and behaviors from a superclass.

Dynamic Typing: The method a computer executes on an object is determined by the run-time type of the object, not the declared type. Static Typing: The method a computer executes on an object is determined by the declared type of the object.

'extends': Used to inherit from a superclass. 'super': Used to call the constructor or methods of the superclass from within the subclass.

Interface: Specifies a contract for classes to implement. Abstract Class: Provides a partial implementation and can contain both abstract and concrete methods.

Composition: Building complex objects by combining simpler objects. Inheritance: Creating new classes based on existing classes, inheriting their properties and behaviors.

Overriding: A subclass method with the same signature as a superclass method. Hiding: A subclass method with the same signature as a static superclass method.

Early Binding: Method call is resolved at compile time. Late Binding: Method call is resolved at runtime (used in polymorphism).

IS-A: Represents inheritance (e.g., a Dog IS-A Animal). HAS-A: Represents composition (e.g., a Car HAS-A Engine).

Reduces code duplication and makes code more maintainable by allowing subclasses to specialize superclass behavior without rewriting code.

Constructors are specific to the class and responsible for initializing the object's state, which may vary between superclasses and subclasses.

The run-time type of the object, not the declared type, determines which method is executed.

To provide a human-readable string representation of an object's state, instead of the default memory reference.

To achieve abstraction, reduce code duplication, and increase code maintainability.

By allowing classes to inherit properties and behaviors from more general classes, mirroring the structure of real-world objects and categories.

It serves as the root of the class hierarchy, providing default implementations for essential methods and ensuring all objects share a common ancestor.

The method a computer executes on an object is determined by the run-time type of the object, not the declared type.

The method a computer executes on an object is determined by the declared type of the object.

The super keyword can be used to access the implementation in the Vehicle class, and then adds additional code to enable the car's cruise control system.

GUI elements like buttons and text fields inherit from a base Widget or Component class, allowing them to share common properties and behaviors.

Different database drivers can be used through a common interface, allowing the application to interact with various database systems without code changes.

Game entities like characters and items inherit from a base Entity class, enabling code reuse and a structured game world.

Collections can store objects of different classes that implement a common interface, allowing for generic operations on diverse data types.

Different types of filesystems (e.g., FAT32, NTFS) can inherit from a base Filesystem class, providing a common interface for file operations.

Plugins can implement a common interface, allowing the main application to interact with them in a uniform way, regardless of their specific implementation.

Controllers and models can inherit from base classes, providing a structured way to handle web requests and data management.

Different device drivers can implement a common interface, allowing the operating system to interact with them in a uniform way, regardless of the specific hardware.

Different types of particles or agents can inherit from a base Particle class, allowing for complex simulations with diverse behaviors.

Different types of financial instruments (e.g., stocks, bonds) can implement a common interface for valuation and risk analysis.