Java泛型参数本身使用泛型？

本文介绍了Java泛型参数本身使用泛型？的处理方法，对大家解决问题具有一定的参考价值，需要的朋友们下面随着小编来一起学习吧！ 问题描述

我试图弄清楚如何使用Java的泛型来构造一个程序，并且想知道我是在做一些根本性错误还是只是在代码中缺少一个简单的错误。假设我有一个泛型类：

public interface Handler< T> { public void process（T吨）; $ / code>

另一个泛型类将Handler作为泛型参数（伪代码） p>

public interface Processor< S extends Handler< T>> {//< ==错误：无法找到符号'T' public void addHandler（S u）; public void process（T t）; $ / code>

提供锅炉实现的抽象实现

public abstract class ProcessorImpl< .....>执行处理器< .....> { ... }

<将处理器想象成一个对象，它将调度请求处理数据给任意数量的处理程序。具体实例可以是流程管道，拦截过滤器，事件系统等的变体。

我希望能够像下面这样使用它：

处理程序< String> myHandler1 = new HandlerImpl< String>（）; Handler< String> myHandler2 = new HandlerImpl< String>（）; Handler< Integer> myHandler3 = new HandlerImpl< Integer>（）; 处理器< Handler< String>> proc = ProcessorImpl< Handler< String>>（）; proc.addHandler（myHandler1）; proc.addhandler（myHandler2）; proc.addhandler（myHandler3）; //这应该是一个错误！

我无法让它起作用。在纸上，它看起来应该是微不足道的，任何想法？

谢谢

解决方案

因此，每个类型参数仅在类中定义，因此 T 未在处理器 class。

您可能想要处理器为：

public interface Processor< T> { public void addHandler（Handler<？super T> u）; public void process（T t）; $ / code>

在这里你声明一个处理器只能处理特定类型的事件/输入，例如字符串，整数等等，所以下面的语句将是有效的：

处理器< String> proc = ... proc.addHandler（new Handler< String>（））; // valid proc.addHandler（new Handler< Object>（））; //有效，因为字符串也是对象 proc.addHandler（new Handler< Integer>（））; //无效，不是字符串处理程序 proc.process（good）; // valid proc.process（1）; //无效，不是字符串

如果处理器是为了在运行时处理类型并根据适当的运行时类型进行动态分派，然后你可以声明 proc （在最后一个例子中）为处理器和LT;？> 。那么所有的陈述都是有效的。

I'm trying to figure out how to structure a program using Java's generics, and wondering if I am doing something fundamentally wrong or just missing a simple bug in my code.

Say I have a generic class:

public interface Handler<T>{ public void process(T t); }

Another generic class takes Handler as a generic parameter (pseudo code):

public interface Processor<S extends Handler<T>>{ //<== Error: cannot find symbol 'T' public void addHandler(S u); public void process(T t); }

Abstract implementation providing boiler-plate implementations

public abstract class ProcessorImpl<.....> implements Processor<.....>{ ... }

Think of a processor as an object that dispatches requests to process data to any number of handlers. Specific instances can be variations of process pipelines, intercepting filters, event systems, etc.

I'd like to be able to use it like the following:

Handler<String> myHandler1 = new HandlerImpl<String>(); Handler<String> myHandler2 = new HandlerImpl<String>(); Handler<Integer> myHandler3 = new HandlerImpl<Integer>(); Processor<Handler<String>> proc = ProcessorImpl<Handler<String>>(); proc.addHandler(myHandler1); proc.addhandler(myHandler2); proc.addhandler(myHandler3);//this should be an error!

I can't get it to work. On paper it looks like it should be trivial, any ideas?

Thanks

解决方案

So each type parameter is only defined within the class, thus T isn't defined or available in Processor class.

You probably want to have Processor be:

public interface Processor<T>{ public void addHandler(Handler<? super T> u); public void process(T t); }

Here you are declaring a Processor that can only handle events/input of a particular type, e.g. String, Integer, etc. So the following statement will be valid:

Processor<String> proc = ... proc.addHandler(new Handler<String>()); // valid proc.addHandler(new Handler<Object>()); // valid, as Strings are Objects too proc.addHandler(new Handler<Integer>()); // invalid, not a String handler proc.process("good"); // valid proc.process(1); // invalid, not a String

If Processor is intended to handle types at runtime and makes a dynamic dispatch based on the appropriate runtime type, then you can declare proc (in the last example) as Processor<?>. Then all the statements are valid.