Java Generics：使用通用 class 作为另一个通用 ZA2F2ED4F8EBC2CBB4C21A29DC40AB6 的类型参数

Question

Is there any way in Java to use a generic class as a type parameter of another generic class?

For example, I have Message and MessageBus like this:

public interface Message<V> {};

public interface MessageBus {
    <V> V execute(Message<V> message);
}

It works well now.

And then, I get Command and CommandBus like this:

public interface Command<V> {};

public interface CommandBus {
    <V> V execute(Command<V> command);
}

It works well, too.

But, the implementation of CommandBus is almost the same as MessageBus . I want to define MessageBus as a generic class like this:

public interface Message<V> {};
public interface MessageBus<T extends Message> {};
public interface Command<V> extends Message<V> {};
public interface CommandBus extends MessageBus<Command> {};

It seems to be fine, but problem comes when I want to define method execute :

public interface MessageBus<T extends Message> {
    <V> V execute(T<V> message);       // compiles error, T<V> is invalid
    <V> V execute(T message);          // T means Message<Object>, not Message<V>
    <V> V execute(Message<V> message); // CommandBus cannot override Message<V> to Command<V> in subclass
}

Note that V is different type on each call, so I cannot define MessageBus like this:

public interface MessageBus<V, T extends Message<V>> {
    /**
     * In this way, each bus can have only one fixed return type.
     * But different return type is expected on different message,
     * just like the first interface above.
     */
    V execute(T message);
}

I want to use them like this:

public class Command1 implements Command<Integer> {};
public class Command2 implements Command<String> {};
public class Command3 implements Command<String> {};
public class Message1 implements Message<String> {};

CommandBus commandBus;
Integer v1 = commandBus.execute(new Command1());  // fine
String v2 = commandBus.execute(new Command2());   // fine
String v3 = commandBus.execute(new Command3());   // fine
String v4 = commandBus.execute(new Command1());   // should compile error, return type mismatch
String v5 = commandBus.execute(new Message1());   // should compile error, only support Command

I will have kinds of MessageBus , like CommandBus extends MessageBus<Command> , QueryBus extends MessageBus<Query> , EventBus extends MessageBus<Event> and so on.

How would I implement this behavior?

Thanks.

Answer 1

You lost the T from Message , which was the original return type.

public interface Message<T> {};
public interface MessageBus<T> {};
public interface Command<T> extends Message<T> {};
public interface CommandBus<T> extends MessageBus<T> {};

Now your classes will be like

class MessageBus<String> {
    String execute(Message<String> m) { ... }
}
class CommandBus<Integer> {
    String execute(Message<Integer> m) { ... }
    Integer execute(Command<Integer> c) { ... }
}

Answer 2

„ …How would I implement this behavior?… “

Here's how I'd implement it …

public interface MessageBus< S extends Foo< ? > > {

    < T extends Foo< U >, U > U execute( T message );
}

I introduced the Foo interface you see there because in order to be able to do what you say you want to do — and do it in a type safe way — Message and Command needed to be the same type .

In the context of this representative example , Foo takes on the responsibility of that necessary commonality. You'd rename Foo to be something more meaningful in your actual business domain.

„ ...I want to use them like this :“

 ... public class Command1 implements Command<Integer> {}; public class Command2 implements Command<String> {}; public class Command3 implements Command<String> {}; public class Message1 implements Message<String> {}; ...

In my demo I've confirmed that the solution is usable like this…

    CommandBus commandBus = new StandardCmdBus() ;
    
    CharSequence v0 = commandBus.execute(new CharSeqCommand());   
    
    Integer v1 = commandBus.execute(new IntegerCommand());    // fine
    
    String v2 = commandBus.execute(new StringCommand());      // fine    
    
    String v3 = commandBus.execute(new StringMessage());      // fine
    
    /*String v4 = commandBus.execute(new CharSeqCommand());*/ // error: incompatible types: inference variable U has incompatible bounds

With the concrete Messages and Commands that I also introduced, this gets printed to stdout …

 Hail Bopp!
        666
Heal Setan!
Hell Santa!

Answer 3

You already know, from the various compilation errors you got originally, your original implementation can't do what you've now clarified is what you actually want to do. In the comments to his/her answer @daniu aludes to one reason why that is.

Your original code wants to do something the language forbids . Namely: Override a method using a signature that's totally different from the super signature .

So you don't want to structure your application the way the code in your original question illustrated. To do what you say it is you actually want to do, your original code needs some significant refactors. So does the code in my first answer. Hence this separate answer…

public interface MessageBus< V > { 
    
    V evaluate( Message<V> msg );
}

public interface CommandBus< V > { 
    
    V evaluate( Command<V> msg );
}

public interface EventBus< V > { 
    
    V evaluate( Event<V> msg );
}
...
public interface Message < V >{ 
    
    V evaluate( );
}
public interface Command< V > extends Message< V >{ 
    
    V evaluate( );
}
...
public class StandardCmdBus { 
    
    public static <S, T extends Command<S>> S evaluate( T cmd ){ return cmd.evaluate();  }
}

I demonstrate how that could be actually used like this…

public static void main(String args[]) {
  
    Stream< Command< ? > > shellCmds = of( () -> 3.14, () -> "javac", () -> "gcc", () -> 42.424242D, () -> "grep", () -> 666);
    
    Stream< Command< ? > > robotCmds = of( () -> "Assemble 666,666,666,666 Cars!", () -> "Exterminate!", () -> "Disallow: /questions/63242515/", () -> 777.9311, () -> "Rescue Will Robinson!", () -> "Kill all humans!", () -> 666);
    
    Stream< Message< ? > > msgs = of( () -> "What hath God wrought?", () -> "Sending out an S.O.S...", () -> "I like apples...", () -> 666, () -> "Friends of space, how are you all? Have you eaten yet? Come visit us if you have time.", () -> "?.?.?", () -> "The answer is...", () -> 42);

    Stream< Event< ? > > evts = of( () -> "The Big Bang", () -> "First Contact", () -> 867.5309, () -> "The Moon Landing", () -> "onLoad()", () -> 666, () -> "The Rapture" );
    
    Stream< Query< ? > > queries = of( () -> "The Ultimate Query...", () -> 42 );
    
    CommandBus< ? > cmdBus = ( cmd ) -> cmd.evaluate( );
    
    MessageBus< ? > msgBus = ( msg ) -> msg.evaluate( );
    
    EventBus< ? > evtBus = ( evt ) -> evt.evaluate( );
    
    QueryBus< ? > qBus = ( q ) -> q.evaluate( );
    
    /* Totally type safe; no unchecked warnings (i.e. no casts invovled) */
    robotCmds.map( StandardCmdBus::evaluate ).forEach( out::println );
    
    /* Less type safe; But totally fine; „uses unchecked or unsafe opertions“ (i.e. casts invovled) */
    use( shellCmds, cmdBus::evaluate ); 
    
    use( msgs, msgBus::evaluate ); 
    
    use( evts, evtBus::evaluate );
    
    use( queries, qBus::evaluate );
    
    Message< String > wtf = ( ) -> "// should compile error";
    
    /* cmdBus.evaluate( wtf );*/ /* error: incompatible types: Message<String> cannot be converted to Command<CAP#1> */ 
    
}

…Which prints out…

Assemble 666,666,666,666 Cars!
Exterminate!
Disallow: /questions/63242515/
777.9311
Rescue Will Robinson!
Kill all humans!
666
...
-----------

What hath God wrought?
Sending out an S.O.S...
I like apples...
666
Friends of space, how are you all? Have you eaten yet? Come visit us if you have time.
?.?.?
The answer is...
42        
...
-----------

The Ultimate Query...
42

...

Your original implementation uses Generics sort of over-zealously. We all are guilty of that at some point. They are a cool form of polymorphism. But used in the wrong way, they cause more problems than they solve.

Answer 4

„ … CommandBus IS A special MessageBus … “

Consider the following class structure. Think of MessageBus as Animal , CommandBus as Cat , Message analogous to Food and Candy analogous to Command …

 +----------------+
 |     Animal     |
 +----------------+                +----------------+
 |eat(Food)       |                |      Food      |
 |                                 |                |
 |                |                +--------^-------+
 +-------^--------+                         |
         |                                  |
         |                      >-----------------------<
 +----------------+             |                       |
 |      Cat       |    +----------------+      +----------------+
 +----------------+    |      Candy     |      |      Grass     |
 |eat(Food)       |    |                |      |                |
 |eat(Candy)      |    +----------------+      +----------------+
 |eat(Grass)      |
 +----------------+

Anything that „ IS A Animal “ absolutely MUST „ eat(Food) “. If it doesn't eat food, then it is NOT an Animal . That is what inheritance is all about.

Analogously: Anything that „ IS A MessageBus “ absolutely MUST „ execute(Message) “. If it doesn't execute a message, then it is NOT a MessageBus .

To say: „ A command bus should only send commands, no other messages “ is exactly like saying: „ A Cat should only eat Candy , no other Food “. If it doesn't eat Food , then it is NOT an Animal .

Sure, a Cat can eat Candy and Grass under specialized circumstances. It's not a Cat's default behavior though.

„… I'd like inheritance and generics… “

It is possible to have both. But I think the expectations you have for combining them, are not possible.

If you truly want inheritance, then you must accept that a Cat MUST eat(Food) . If you want a CommandBus that does not execute(Message) , then you do not want inheritance.

Sure, it's possible to implement a CommandBus to execute(Command) . But that must be in addition to execute(Message) Because of inheritance , execute(Message) is the default behavior for CommandBus .