What do you mean by polymorphism? How multiple inheritance is obtained in JAVA? Explain with an example.

 Polymorphism is a fundamental concept in object-oriented programming that allows objects of different classes to be treated as if they were of the same class. Polymorphism enables code to be written that can work with objects of different types, as long as those objects share a common interface or superclass. Polymorphism is achieved in Java through two mechanisms: method overloading and method overriding.

Method overloading is when a class has multiple methods with the same name but different parameter types. When an overloaded method is called, the Java compiler selects the method to call based on the types of the arguments passed to it.

Method overriding is when a subclass provides its own implementation of a method that is already defined in its superclass. When an overridden method is called, the Java runtime system determines which version of the method to call based on the actual type of the object at runtime.

Multiple inheritance is not supported in Java, which means that a class cannot extend more than one superclass. However, Java provides a mechanism called interface that allows a class to implement multiple interfaces, which can be thought of as a form of multiple inheritance of types. An interface is a collection of abstract methods that define a set of behaviors or capabilities that a class can provide. A class that implements an interface must provide an implementation for all of its methods.

Here is an example that demonstrates how to use interfaces to achieve multiple inheritance of types in Java:

interface A {
   void methodA();
}
interface B {
   void methodB();
}
class MyClass implements A, B {
   public void methodA() {
      System.out.println("Method A");
   }
   
   public void methodB() {
      System.out.println("Method B");
   }
}
public class Main {
   public static void main(String[] args) {
      MyClass obj = new MyClass();
      obj.methodA();
      obj.methodB();
   }
}

In this example, we define two interfaces, A and B, each of which has a single method. We then define a class MyClass that implements both interfaces and provides an implementation for each of their methods. Finally, we create an instance of MyClass and call its methodA() and methodB() methods, which output "Method A" and "Method B", respectively. Since MyClass implements both interfaces, it can be treated as an object of either type A or B, which demonstrates the polymorphic behavior of Java interfaces.