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.

A general class that serves as a parent or base class for other classes.

Classes that are derived from a superclass and inherit its methods and attributes.

The ability of a subclass to inherit or acquire the properties of its parent class.

When a subclass defines a method with the same method signature as the superclass.

The concept that you can access objects of different types through the same interface or superclass.

A set of classes connected by a parent-child relationship, where each class inherits characteristics from its parent.

Used to refer to the constructor or methods of the parent class from within the subclass.

Used in the header of a subclass to inherit from a superclass.

The superclass to all other classes in Java, defining basic methods like equals() and toString().

Free Response Question.

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).