继承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 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 will
return 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 will
return 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 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.java

Once 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 implements
OddInterface {
public OddChild() {
super();
} // constructor

public OddChild(int start) {
super(start);
} // constructor

} // OddChild




Listing 1.4: OddChild.java

With 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 implements
OddInterface {
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.java

Unfortunately, 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 instance

In 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.