A potential downside to using inheritance is the tight coupling between superclass and subclass, which can lead to fragile code. For instance, if the Bicycle class is modified, all subclasses like MountainBike could require updates, risking broken functionality if not handled carefully. A solution to mitigate this is to use interfaces or composition over inheritance where appropriate, providing more flexibility in the structure and reducing dependency by having subclasses implement necessary behaviors rather than inheriting them outright .

Both the Bicycle and MountainBike classes use constructors, but they serve different purposes aligned with their class structures. The Bicycle class constructor initializes gear and speed, the two primary attributes of a bicycle. In contrast, the MountainBike class calls the Bicycle constructor using the super keyword to initialize the inherited attributes and extends functionality by initializing the additional seatHeight attribute. This demonstrates the use of constructors in a single and subclass context to ensure that all class attributes, both inherited and new, are properly initialized .

Inheritance significantly affects code maintainability by promoting reuse and reducing redundancy. In the given code examples, the Car class inherits methods and fields from Vehicle, ensuring any changes to Vehicle are automatically reflected in Car without additional effort. Similarly, changes in the Bicycle class will propagate to MountainBike, keeping extended features consistent and reducing duplicated code across related classes. This centralized control improves maintainability, minimizes the chance of errors due to duplicated logic, and simplifies updates across an inheritance hierarchy .

Polymorphism is illustrated between the Vehicle and Car classes through the inheritance and method usage. The Car class inherits the honk() method from Vehicle and can call it on its objects, showcasing polymorphism where the Car object can behave like a Vehicle. This allows code written for Vehicle types to be used with Car objects, enabling flexibility and extensibility in code where a common interface or superclass allows interaction irrespective of the specific subclass type being used .

In the Java inheritance examples, the access specifier 'protected' in the Vehicle class allows the brand field to be accessible directly within the Car subclass, despite being in different packages or classes. Protected access allows the members to be accessed not just within the same class or package but also by subclasses, thereby promoting encapsulation while sharing necessary details with related classes, an essential balance between hiding and visibility in object-oriented programming .

Overriding the toString() method in Java classes is beneficial because it provides a string representation of the object's state, making it easier to understand and debug. In the examples, overriding toString() in the MountainBike class allows it to include specific information about the bike's gear, speed, and seat height. This aids in clear output when the object's information needs to be printed, tailored to the class's unique attributes, enhancing readability and usability in print statements .

The primary benefit of using inheritance in object-oriented programming, as illustrated by the Java examples, is code reuse. Inheritance allows a new class to inherit fields and methods from an existing class, which reduces code duplication and enhances maintainability. For example, the 'Car' class inherits the 'brand' field and 'honk' method from the 'Vehicle' class, and the 'MountainBike' class inherits from the 'Bicycle' class adding new behavior while reusing the 'Bicycle' structure .

The 'super' keyword is used in the MountainBike class constructor to invoke the constructor of its superclass, Bicycle. This ensures that the inherited fields, gear and speed, are initialized with the correct values provided at the creation of a MountainBike object. Without calling super, the subclass would not be able to properly set these inherited properties, which could lead to uninitialized or unintended values being used, thus affecting functionality and structural integrity of the subclass objects .

In the given examples, method overriding is demonstrated by the MountainBike class's toString() method. This method overrides the toString() method in the Bicycle class to enhance its functionality by adding a printout of the seat height attribute. This is significant because it allows subclasses to provide specific implementations of methods that are defined in the parent class, thereby enabling polymorphic behavior where the subclass method is invoked at runtime, showing a custom output relevant to MountainBike instances .

Encapsulation is demonstrated in the Bicycle and MountainBike classes by defining fields as public and providing methods to manipulate these fields, instead of allowing direct access to them. While the fields gear, speed, and seatHeight are public, the classes primarily access or modify these fields through respective methods like applyBrake(), speedUp(), and setHeight(). This encapsulation allows control over how the data is modified and maintained, ensuring internal data integrity and abstraction from user interactions .