Simulating Multiple Inheritance in JavaArticle 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 with the NextOdd
and NextEven
classes, shown in Listing 1.1 and Listing 1.2 respectively. We will then create a new class, which we will call EvenOdd
, 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.javaAs Java only allows for extending a single class through the extends
keyword, we will have to provide another manner for extending more than one class. In this example, we will extend the NextEven
class by using the extends
keyword and use a new interface, which we will call OddInterface
, and an implementation of the new interface, which we will call OddChild
, to extend the NextOdd
class.
The first step in extending the NextOdd
class is to define an interface with the same methods as the NextOdd
class, 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.javaOnce we have created OddInterface
, the next step is to create an implementation of OddInterface
that also extends the NextOdd
class, as shown in Listing 1.4. By extending the NextOdd
class, which, as previously explained, has all the same method prototypes as OddInterface
, we do not have to implement any of the methods in OddInterface
and only have to provide constructors for the new class, which we will call OddChild
. These constructors simply call the constructors of the NextOdd
class using the super() method. The OddChild
class now provides the exact implementation of all methods of the NextOdd
class, without the developer having to know anything about the way in which NextOdd
was originally implemented.
public class OddChild extends NextOdd implementsOddInterface { public OddChild() { super(); } // constructor public OddChild(int start) { super(start); } // constructor} // OddChild |
|
Listing 1.4: OddChild.javaWith our implementation of the OddInterface
class, we can now create a class that will extend both the NextEven
class and the NextOdd
class. This new class will be called EvenOdd
and is shown in Listing 1.5. Because Java allows you to extend only a single class, EvenOdd
will extend the NextEven
class and use OddInterface
and OddChild
to extend the NextOdd
class.
In order to be able to call the EvenOdd.getNextOdd()
method, EvenOdd
will implement OddInterface
because OddInterface
has all the same method prototypes as NextOdd
. This means that we also must provide an implementation of all the OddInterface
methods, and as a result all the NextOdd
methods, within EvenOdd
. To ensure these methods have the same implementation as the NextOdd
methods, we will create a private instance of the OddChild
class, which we will call oddGenerator
, and call the respective oddGenerator
method. For example, in the EvenOdd.getNextOdd()
method, we call oddGenerator.getNextOdd()
. The EvenOdd
class now provides the same functionality and implementation of both the NextOdd
and NextEven
classes.
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 |
|
Listing 1.5: EvenOdd.javaUnfortunately, because Java does only allow you to extend a single class, you will only be able to cast the EvenOdd
class to a NextEven
class and not to a NextOdd
class as you would be able to if multiple inheritance were directly supported by Java. If you wish to be able to cast an EvenOdd
object to a NextOdd
class, you will have to provide a method for extracting an instance of the NextOdd
class similar to the getNextOddObj()
method in Listing 1.6.
public NextOdd getNextOddObj() { return (NextOdd)oddGenerator;} // getNextOdd |
|
Listing 1.6: Returning a NextOdd instanceIn fact, this multiple inheritance limitation is often avoided by creating a factory class with many methods similar to Listing 1.6.
Summary
- Create an interface with all the same method prototypes as the base class you will be extending.
- Create a class that implements the interface created in step 1 and extends the base class.
- 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.