How to simulate multi-inheritance in Java

Simulating multiple inheritance in Java

Article Author: Mike Van Atter
From book: codenotes for Java
Date published: February 1, 2002 purpose of multiple inheritance

Multiple inheritance allows a single class to extend two parent classes and thus provide the methods of both parent classes. unlike C ++, Java does not explicitly support multiple inheritance, allowing a class to extend only a single parent class. however, as we will show in this article, it is possible to simulate multiple inheritance, allowing a single class to provide the methods, and the respective implementations, of two parent classes. the strategy that is introduced in this article is also easily extendible to provide inheritance of three or more parent classes.

Simulating multiple inheritance

In this article we will use a simple example to demonstrate how to simulate multiple inheritance in Java. We will begin withNextOddAndNextEvenClasses, shown in listing 1.1 and listing 1.2 respectively. We will then create a new class, which we will callEvenOdd, That provides the functionality of both classes.

// Repeated calls to the getNextOdd method willreturn the next// odd number (i.e. the first call will return 1, the second// call 3, etc.public class NextOdd { // the last odd number returned by the getNextOdd method private int lastOdd = -1; public NextOdd() { this.lastOdd = -1; } // NextOdd // selects a different starting point for the odd numbers // ensures that the starting point is in fact an odd number public NextOdd(int start) { this.lastOdd = ((int)start/2) * 2 + 1; } // NextOdd // Retrieves the next odd number public int getNextOdd() { return lastOdd += 2; } // getNext} // NextOdd

Listing 1.1: nextodd. Java

// Repeated calls to the getNextEven method willreturn the // next even number (i.e the first call will return 0, the // second call will return 2, etc.)public class NextEven { // the last even number returned by getNextEven private int lastEven = -2; public NextEven() { this.lastEven = -2; } // NextEven // selects a different starting point for the even numbers // ensures that the starting point is in fact an even # public NextEven(int start) { this.lastEven = ((int)(start/2)) * 2; } // constructor // retrieves the next even number public int getNextEven() { return lastEven +=2; } // getNextEven} // NextEven

Listing 1.2: nexteven. Java

As Java only allows for extending a single class throughextendsKeyword, we will have to provide another manner for extending more than one class. In this example, we will extendNextEvenClass by usingextendsKeyword and use a new interface, which we will callOddInterface, And an implementation of the new interface, which we will callOddChild, To extendNextOddClass.

The first step in extendingNextOddClass is to define an interface with the same methods asNextOddClass, as shown in Listing 1.3. Notice that the parameters, function names, and return values for all methods in the interface must be the same as the original class.

public interface OddInterface { public int getNextOdd();} // OddInterface

Listing 1.3: OddInterface. java

Once we have createdOddInterface, The next step is to create an implementationOddInterfaceThat also extendsNextOddClass, as shown in Listing 1.4. By extendingNextOddClass, which, as previusly explained, has all the same method prototypesOddInterface, We do not have to implement any of the methods inOddInterfaceAnd only have to provide constructors for the new class, which we will callOddChild. These constructors simply call the constructors ofNextOddClass using the super () method.OddChildClass now provides the exact implementation of all methods ofNextOddClass, without the developer having to know anything about the way in whichNextOddWas originally implemented.

public class OddChild extends NextOdd implementsOddInterface { public OddChild() { super(); } // constructor public OddChild(int start) { super(start); } // constructor} // OddChild

Listing 1.4: OddChild. java

With our implementation ofOddInterfaceClass, we can now create a class that will extend bothNextEvenClass andNextOddClass. This new class will be calledEvenOddAnd is shown in Listing 1.5. Because Java allows you to extend only a single class,EvenOddWill extendNextEvenClass and useOddInterfaceAndOddChildTo extendNextOddClass.

In order to be able to callEvenOdd.getNextOdd()Method,EvenOddWill implementOddInterfaceBecauseOddInterfaceHas all the same method prototypesNextOdd. This means that we also must provide an implementation of allOddInterfaceMethods, and as a result allNextOddMethods,EvenOdd. To ensure these methods have the same implementation asNextOddMethods, we will create a private instance ofOddChildClass, which we will calloddGenerator, And call the respectiveoddGeneratorMethod. For example, inEvenOdd.getNextOdd()Method, we calloddGenerator.getNextOdd().EvenOddClass now provides the same functionality and implementation of bothNextOddAndNextEvenClasses.

public class EvenOdd extends NextEven implementsOddInterface { public EvenOdd() { super(); oddGenerator = new OddChild(); } // EvenOdd // initializes the starting point of both the odd # generator // and the even # generator public EvenOdd(int oddStart, int evenStart) { super(evenStart); oddGenerator = new OddChild(oddStart); } // EvenOdd public int getNextOdd() { return oddGenerator.getNextOdd(); } // getNextOdd private final OddInterface oddGenerator;} // EvenOdd

Listing1.5: EvenOdd. java

Unfortunately, because Java does only allow you to extend a single class, you will only be able to castEvenOddClass toNextEvenClass and not toNextOddClass as you wocould be able to if multiple inheritance were directly supported by Java. If you wish to be able to castEvenOddObject toNextOddClass, you will have to provide a method for extracting an instance ofNextOddClass similar togetNextOddObj()Method in Listing 1.6.

public NextOdd getNextOddObj() { return (NextOdd)oddGenerator;} // getNextOdd

Listing 1.6: Returning a NextOdd instance

In fact, this multiple inheritance limitation is often avoided by creating a factory class with your methods similar to Listing 1.6.

Summary

1. Create an interface with all the same method prototypes as the base class you will be extending.
2. Create a class that implements the interface created in step 1 and extends the base class.
3. In the child class, implement the interface created in step 1 and create a private instance of the class defined in step 2. in all the methods defined in the interface, simply call the corresponding method in the class created in step 2.