Java does not support multiple inheritance with classes to avoid ambiguity caused by the “Diamond Problem,” where a class inherits from two classes having methods with the same name. However, interfaces allow Java to achieve multiple inheritance because they do not contain method implementations (except default methods), thus avoiding conflicts.
Key Concepts
- Multiple Inheritance with Interfaces:
- A class can implement multiple interfaces by separating their names with commas in the implements clause.
- Since interfaces primarily define method signatures (contracts), the implementing class provides the actual method implementations.
- Default Method Conflicts:
- If two interfaces provide conflicting default methods, the implementing class must override and resolve the conflict explicitly.
- Static Methods:
- Interfaces can have static methods (introduced in Java 8), but they are not inherited by implementing classes.
Syntax
interface InterfaceA {
void methodA();
}
interface InterfaceB {
void methodB();
}
class MultiInheritanceExample implements InterfaceA, InterfaceB {
public void methodA() {
System.out.println(“Implementing methodA from InterfaceA”);
}
public void methodB() {
System.out.println(“Implementing methodB from InterfaceB”);
}
}
Example: Multiple Inheritance Using Interfaces
interface Vehicle {
void start();
}
interface Engine {
void run();
}
class Car implements Vehicle, Engine {
public void start() {
System.out.println(“Car is starting…”);
}
public void run() {
System.out.println(“Engine is running…”);
}
}
public class Main {
public static void main(String[] args) {
Car myCar = new Car();
myCar.start();
myCar.run();
}
}
Output:
Car is starting…
Engine is running…
Handling Conflicts in Default Methods
If two interfaces have the same default method, the implementing class must override and resolve the conflict.
Example: Default Method Conflict Resolution
interface InterfaceA {
default void display() {
System.out.println(“Default method from InterfaceA”);
}
}
interface InterfaceB {
default void display() {
System.out.println(“Default method from InterfaceB”);
}
}
class MultiInheritanceExample implements InterfaceA, InterfaceB {
// Overriding to resolve conflict
@Override
public void display() {
System.out.println(“Overridden method in implementing class”);
}
}
public class Main {
public static void main(String[] args) {
MultiInheritanceExample obj = new MultiInheritanceExample();
obj.display();
}
}
Output:
Overridden method in implementing class
Example: Using Multiple Interfaces for Modular Design
interface Printer {
void print();
}
interface Scanner {
void scan();
}
class MultiFunctionPrinter implements Printer, Scanner {
public void print() {
System.out.println(“Printing document…”);
}
public void scan() {
System.out.println(“Scanning document…”);
}
}
public class Main {
public static void main(String[] args) {
MultiFunctionPrinter mfp = new MultiFunctionPrinter();
mfp.print();
mfp.scan();
}
}
Output:
Printing document…
Scanning document…
Advantages of Multiple Inheritance Using Interfaces
- Flexibility:
- A class can inherit behavior from multiple sources without ambiguity.
- Decoupled Design:
- Promotes separation of concerns by defining specific behaviors in individual interfaces.
- Polymorphism:
- An object can be referred to as multiple types (e.g., Vehicle, Engine).
- Avoids Diamond Problem:
- Since interfaces do not provide concrete implementations (except default methods), there is no conflict in inheritance.
Limitations
- Overhead of Implementation:
- The implementing class must provide implementations for all abstract methods from multiple interfaces.
- Default Method Conflicts:
- Requires explicit resolution when two interfaces have the same default method.
Comparison: Multiple Inheritance in Classes vs Interfaces
| Feature | Classes | Interfaces |
| Method Implementation | Concrete methods are inherited. | Abstract methods need implementation. |
| Conflict Handling | Causes ambiguity (Diamond Problem). | Explicitly resolved by overriding. |
| Flexibility | Not supported. | Supported using implements. |
| Static Methods | Inherited by subclasses. | Not inherited by implementing classes. |
Best Practices
- Use Interface Segregation:
- Split large interfaces into smaller, more focused ones for clarity and modularity.
- Resolve Conflicts Explicitly:
- When using default methods, always handle conflicts explicitly in the implementing class.
- Avoid Overuse:
- Do not implement unnecessary interfaces to avoid bloated or confusing code.
Conclusion
Multiple inheritance using interfaces in Java provides a powerful and flexible mechanism to inherit behaviors from multiple sources while avoiding the complexity of multiple inheritance in classes. This approach ensures a clean, modular design and is essential for building scalable and maintainable applications.