Method overloading in the Exam class demonstrates static polymorphism by defining multiple `show` methods with different parameter lists. During compile time, the Java compiler determines which `show` method to call based on the number and type of arguments passed in. For example, `show()` is called without parameters, `show(String name)` is called when a single string is passed, and `show(String name, String role)` is called when two strings are passed. This allows different behaviors without changing the method name .

Multi-level inheritance in the example involves a class hierarchy where class C inherits from class B, which in turn inherits from class A. This chain of inheritance allows class C to access protected and public members of both class B and class A through the `super` keyword. Specifically, class C's constructor uses `super(x, y)` to initialize its superclass B, which in turn uses `super(x)` to initialize class A. The `show()` method in class C accesses and prints the values `x`, `y`, and `s` showing inheritance of properties from classes B and A .

Compile-time binding, also known as static binding, decides the method to invoke at compile-time based on the method signature and overloading, such as determining which variant of an overloaded method to call based on parameter types. Run-time binding, or dynamic binding, defers this decision to run-time, as seen in polymorphism where the overridden method call is determined by the actual object's type, allowing for method overriding behavior seen in inheritance scenarios .

Method overriding occurs when a derived class provides a specific implementation of a method already defined in its base class, enabling run-time polymorphism. The document does not provide an explicit overriding example but outlines class hierarchy usage implying method sharing. In contrast, method overloading, shown in the Exam class, allows multiple methods within the same class to share the same name but differ in parameters, achieving compile-time polymorphism. Overloading focuses on method signature variance, while overriding depends on inheritance for method behavior specialization .

Hierarchical inheritance allows multiple classes to inherit from a single base class. In the example, classes Addition and Subtraction both inherit from the Input class. This design enables the derived classes to use the input fields `x`, `y`, and `res`, as well as the method `show()` from the Input class, while implementing their specific functionalities: `sum()` in Addition and `sub()` in Subtraction. This design facilitates code reuse and logical segmentation of arithmetic operations .

Encapsulation in the Exam class enhances functionality by defining multiple `show` methods with varying parameters to handle different input scenarios without exposing internal logic directly. It maintains method calls without revealing underlying implementation through clear method signatures, offering flexibility and simplicity in interaction. For example, different messages are constructed internally based on provided arguments, keeping data processing internal while maintaining a consistent interface .

Encapsulation in the hierarchical inheritance example is demonstrated through the protected access modifier used for the variables `x`, `y`, and `res` in the Input class, allowing them to be used by derived classes Addition and Subtraction. This design maintains data integrity by managing access through controlled methods such as `show` and ensures that only classes inheriting Input access these fields directly. Thus, encapsulation promotes modularity and data protection in derived class implementations .

The `super` keyword in multi-level inheritance is used to access parent class members and invoke parent class constructors, fostering member inheritance across multiple class levels. In the provided example, class B calls `super(x)` to initialize variables from class A, and class C calls `super(x, y)` to invoke B's constructor. Moreover, `super` allows C's `show` method to output values of `x` and `y` from classes A and B, respectively, illustrating inheritance efficiency .

Constructor overloading in class A illustrates the use of multiple constructors with different signatures to instantiate an object in various states. The default constructor initializes the member `x` to zero, while the parameterized constructor initializes `x` with a given integer. For instance, creating `A a = new A();` calls the default constructor setting `a.x` to 0, while `A a1 = new A(20);` uses the parameterized constructor setting `a1.x` to 20. This allows flexibility and clarity in object instantiation .

Using the `Scanner` class for input in the Input class offers straightforward text parsing for input operations, enabling dynamic reading of integers from user input. It streamlines data acquisition by integrating intuitive console input mechanisms (`nextInt`), thereby simplifying input handling across inherited classes, such as Addition and Subtraction which rely on initialized values to perform calculations. Additionally, `Scanner` manages different data types, promoting code readability and operational efficiency in interactive applications .