Illustrate how Java supports multiple inheritance.

Java does not support multiple inheritance directly. This is because multiple inheritance can lead to a lot of confusion when methods or variables are named the same across several inherited classes.

However, Java provides a way to achieve multiple inheritance through the use of interfaces. An interface is a reference type in Java, similar to a class, that can contain only constants, method signatures, default methods, static methods, and nested types.

Here's a step-by-step illustration:

1. Define the interfaces: You can define multiple interfaces each with different methods.

interface InterfaceA {
    void methodA();
}

interface InterfaceB {
    void methodB();
}

2. Implement the interfaces: A class can implement any number of interfaces. This is how Java achieves multiple inheritance.

class MyClass implements InterfaceA, InterfaceB {
    public void methodA() {
        System.out.println("Method A");
    }

    public void methodB() {
        System.out.println("Method B");
    }
}

3. Use the implemented methods: Now you can create an object of your class and call any of the methods.

public class Main {
    public static void main(String[] args) {
        MyClass myClass = new MyClass();
        myClass.methodA();  // prints "Method A"
        myClass.methodB();  // prints "Method B"
    }
}

In this way, Java supports the concept of multiple inheritance. It's important to note that interfaces can extend multiple interfaces, which is another way Java supports multiple inheritance.

Java does not support multiple inheritance directly. This is because multiple inheritance can lead to a lot of confusion when methods or attributes are inherited from multiple sources with the same signatures.

However, Java provides a way to achieve multiple inheritance through the use of interfaces. An interface is a reference type in Java, similar to a class, that can contain only constants, method signatures, default methods, static methods, and nested types.

Here's a step-by-step illustration:

1. Define the interfaces: You can define multiple interfaces in Java, each with its own methods. For example:

interface InterfaceA {
    void methodA();
}

interface InterfaceB {
    void methodB();
}

2. Implement the interfaces: A class can implement any number of interfaces. This is done using the 'implements' keyword. For example:

class MyClass implements InterfaceA, InterfaceB {
    public void methodA() {
        System.out.println("Method A");
    }

    public void methodB() {
        System.out.println("Method B");
    }
}

In the above example, MyClass is effectively inheriting from multiple sources (InterfaceA and InterfaceB), which is essentially multiple inheritance.

3. Use the implemented methods: You can now create an object of MyClass and call the methods methodA and methodB.

public class Main {
    public static void main(String[] args) {
        MyClass myClass = new MyClass();
        myClass.methodA();  // prints "Method A"
        myClass.methodB();  // prints "Method B"
    }
}

So, while Java does not support multiple inheritance in the way that some other languages like C++ do, it does provide the tools to achieve similar functionality using interfaces.