Code reusability. Subclasses inherit methods and instance variables from superclasses, reducing code duplication.

Because it promotes abstraction and code organization by establishing hierarchical relationships between classes.

A subclass 'is-a' more specific type of its superclass (e.g., 'APSubject is-a SchoolSubject').

A Java class can only inherit from one superclass (single inheritance).

It allows objects of different classes to be treated as objects of a common type (usually a superclass), enabling flexibility and code extensibility.

It allows subclasses to provide their own specific implementations of methods defined in the superclass, enabling different behaviors for the same method call.

Subclasses inherit the properties and methods of their superclasses, avoiding the need to rewrite the same code in multiple classes.

It is the root of the class hierarchy. Every class in Java directly or indirectly inherits from the Object class.

To create more specialized classes that inherit and extend the functionality of a more general superclass.

Inheritance is an 'is-a' relationship, while composition is a 'has-a' relationship. Inheritance creates a tight coupling between classes, while composition promotes loose coupling.

A mechanism where one class (subclass) acquires the properties (methods and instance variables) of another class (superclass).

The class whose properties are inherited by another class.

The class that inherits properties from another class (the superclass).

The ability of an object to take on many forms. Allows an object to be treated as an instance of its own class or its parent class.

A programming paradigm based on the concept of 'objects', which contain data and code to manipulate that data.

When a subclass provides a specific implementation for a method that is already defined in its superclass.

A keyword used in Java to indicate that a class inherits from another class.

A keyword used to access members of the superclass from within a subclass.

A problem that arises in multiple inheritance where a class inherits from two classes that have a common ancestor, leading to ambiguity in method resolution.

Type checking is done during run-time.

Type checking is done during compile-time.

Superclass: More general, provides base functionality | Subclass: More specific, inherits from superclass and adds/modifies functionality.

Inheritance: 'is-a' relationship, tight coupling | Composition: 'has-a' relationship, loose coupling.

Overriding: Same method signature in subclass and superclass | Overloading: Same method name but different parameters in the same class.

Single Inheritance: A class inherits from only one superclass | Multiple Inheritance: A class inherits from multiple superclasses (not supported in Java directly).

Static typing: Type checking at compile time | Dynamic typing: Type checking at runtime.

Public: Accessible from anywhere | Private: Only accessible within the class where they are defined, not inherited directly.

'extends': Used for inheritance between classes | 'implements': Used for a class to implement an interface.

Abstract Class: Can have method implementations and instance variables | Interface: Only method signatures (before Java 8) and constant variables.

Inheritance: Creates a strong 'is-a' relationship, subclass depends on superclass | Aggregation: Creates a 'has-a' relationship, weaker dependency.

Inheritance: Promotes code reuse, establishes hierarchical relationships | Separate Classes: No inherent relationship, can lead to code duplication.