Inheritance

Inheritance is one of the core principles of OOP and represents an 'is-a' relationship between classes. It allows a new class, known as the subclass (or child class), to be based on an existing class, the superclass (or parent class). The subclass automatically inherits all the non-private members (fields and methods) of its superclass. This is a powerful mechanism for code reuse. For instance, you could have a `Vehicle` superclass with fields like `speed` and methods like `start()`. You could then create subclasses like `Car` and `Bicycle` that `extend` the `Vehicle` class. Both `Car` and `Bicycle` would automatically have the `speed` field and `start()` method without you having to rewrite them. They can also add their own specific fields and methods (e.g., `Car` could have a `numberOfDoors` field). The `super` keyword is used within a subclass to refer to its immediate superclass. It can be used to call the superclass's constructor (`super()`) or to call a superclass's method (`super.methodName()`), which is particularly useful when you override a method but still want to execute the parent's logic. Java supports single inheritance, meaning a class can only extend one other class. However, it supports multilevel inheritance through chaining (A extends B, B extends C). Inheritance is fundamental to building scalable and logical class structures in object-oriented design.