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