Jak prawidłowo połączyć generykę i dziedziczenie, aby uzyskać pożądany rezultat?

Question

Moje pytanie nie jest łatwe do wyjaśnienia za pomocą słów, na szczęście nie jest to zbyt trudne do wykazania. Tak więc pokrywa się ze mną:

public interface Command<R> 
{ 
    public R execute();//parameter R is the type of object that will be returned as the result of the execution of this command 
} 

public abstract class BasicCommand<R> implements Command<R> 
{ 
} 

public interface CommandProcessor<C extends Command<?>> 
{ 
    public <R> R process(C<R> command);//this is my question... it's illegal to do, but you understand the idea behind it, right? 
} 

//constrain BasicCommandProcessor to commands that subclass BasicCommand 
public class BasicCommandProcessor<C extends BasicCommand<?>> implements CommandProcessor<C> 
{ 
    //here, only subclasses of BasicCommand should be allowed as arguments but these 
    //BasicCommand object should be parameterized by R, like so: BasicCommand<R> 
    //so the method signature should really be 
    // public <R> R process(BasicCommand<R> command) 
    //which would break the inheritance if the interface's method signature was instead: 
    // public <R> R process(Command<R> command); 
    //I really hope this fully illustrates my conundrum 
    public <R> R process(C<R> command) 
    { 
     return command.execute(); 
    } 
} 

public class CommandContext 
{ 
    public static void main(String... args) 
    { 
     BasicCommandProcessor<BasicCommand<?>> bcp = new BasicCommandProcessor<BasicCommand<?>>(); 
     String textResult = bcp.execute(new BasicCommand<String>() 
     { 
      public String execute() 
      { 
       return "result"; 
      } 
     }); 
     Long numericResult = bcp.execute(new BasicCommand<Long>() 
     { 
      public Long execute() 
      { 
       return 123L; 
      } 
     }); 
    } 
} 

Zasadniczo chcę rodzajową „proces” metoda dyktować rodzaj parametru rodzajowego obiektu Command. Celem jest umożliwienie ograniczenia różnych implementacji CommandProcessor do niektórych klas implementujących interfejs poleceń, a jednocześnie umożliwienie wywołania metody procesu dowolnej klasy, która implementuje interfejs CommandProcessor i zwrócenie obiektu typu określonego przez sparametryzowany obiekt polecenia. Nie jestem pewien, czy moje wyjaśnienie jest wystarczająco jasne, więc proszę dać mi znać, czy potrzebne są dalsze wyjaśnienia. Chyba pytanie brzmi: "Czy to w ogóle możliwe?" Jeśli odpowiedź brzmi "Nie", to co byłoby najlepszym obejściem (pomyślałem o sobie samemu, ale chciałbym trochę świeżych pomysłów).

Answer 1

Niestety, nie możesz tego zrobić. Ponieważ chcesz, aby interfejs CommandProcessor był zdefiniowany pod kątem Command, twoja implementacja musi być przygotowana na instancję dowolnego typu Command - generics nie może ograniczyć tego do BasicCommand - jeśli mogłoby, wtedy podklasa BasicCommandProcessor nie implementowałaby interfejsu CommandProcessor.

Albo, pod innym kątem, z interfejsem CommandProcessor, generics nie ma możliwości upewnienia się, że zostało to wywołane tylko z instancjami BasicCommand. Aby to zrobić, trzeba znać implementację i byłoby to sprzeczne z punktem polimorfizmu i interfejsów.

Można sparametryzować wynik polecenia, ale nie konkretną klasę poleceń.

Najprostszym sposobem jest zapewnienie metody, która akceptuje konkretny typ, którego potrzebujesz, i wywołanie go w metodzie ogólnej. (Patrz BasicCommandProcessor powyżej.)

Answer 2

Zasadniczo chcę rodzajową „proces” metoda dyktować rodzaj generycznego parametru Command obiektu.

Jest to w sprzeczności z pojęciem definiowania polecenia jako typ parametru do rodzaju otaczającej: Przy uruchamianiu tego CommandProcessor, rzeczywisty typ takich jak Command<String> mógłby być dostarczany do C. Byłoby to nawet możliwe, aby dostarczyć typu non-generic takiego jak

class Foo implements Command<String> { 
    ... 
} 

Jaki sens C<R> byłoby wtedy? Foo<R>? Command<String><R>? Command<R>?

Jakie masz opcje? Jeśli tylko CommandProcessor trzeba pracować z konkretnym rodzajem powrotu, można zrobić:

class CommandProcessor<R, C extends Command<R>> { 
    R process(C command); 
} 

class FancyCommandProcessor<R, C extends FancyCommand<R>> extends CommandProcessor<R,C> { 

} 

Jednak podejrzewam chcesz CommandProcessor pracować z całą rodziną typu poleceń.To samo w sobie byłoby żadnego problemu, po prostu oświadczyć:

<R> R process(FancyCommand<R> command); 

Jeśli jednak chcemy dodatkowo relację między CommandProcessors podtypu dla różnych rodzin poleceń, dzięki czemu można zastąpić process, venture poza ekspresyjności rodzajowych Java. W szczególności potrzebowałbyś albo odpowiednika parametrów typu "szablonu" w C++ (które pozwalają przekazać szablon jako rzeczywisty typ argumentu), albo możliwości przechwytywania parametru typu Command, biorąc pod uwagę faktyczny typ argumentu, o którym wiadomo, że rozszerza komendę . Java nie obsługuje ani.