my questions relates to introducing Generics into legacy Java classes. The legacy classes from the code below that I want to generify are ClientObjectProxy and ClientObjectContainer. ClientObject remains unchanged. For simplicity I put all the classes into one outer class.
Now in the legacy code there are many calls of the method ClientObjectProxyContainer.getProxies() on ClientObjectProxyContainer instances that are not parameterized.
By introducing Generics existing code like in Loop 4 won't compile anymore, the call needs to be extracted to a local variable like in Loop 1 or a declaration with a question mark needs to be used similar to Loop 2. New code should use parameterized variables like in Loop 3.
My question is, is this is the way to go for me, change the existing code to either Loop 1 or Loop 2, or is there's a way of not modifying legacy code?
Thanks
Jan
import java.util.ArrayList;
import java.util.List;
public class GenericForumsExample {
/**
* This class is unchanged
*/
private class ClientObject {
}
/**
* @param <T> Type of the ClientObject behind this proxy
*/
private class ClientObjectProxy<T extends ClientObject> {
}
/**
* @param <T> Type of the ClientObject contained in this collection
*/
private class ClientObjectProxyContainer<T extends ClientObject> {
//Previous signature was:
// public List<ClientObjectProxy> getProxies(){
// New signature is the following
public List<ClientObjectProxy<T>> getProxies(){
return new ArrayList<ClientObjectProxy<T>>();
}
}
public void testScenario() {
ClientObjectProxyContainer proxyContainer = new ClientObjectProxyContainer();
List<ClientObjectProxy> proxies = proxyContainer.getProxies(); // Just a compiler warning
// Loop 1
for (ClientObjectProxy proxy : proxies) { // Compiler OK
//Do something...
}
// Loop 2
ClientObjectProxyContainer<?> clientObjectProxyContainer = new ClientObjectProxyContainer();
for (ClientObjectProxy<?> proxy : clientObjectProxyContainer.getProxies()) {
//Do something...
}
// Loop 3
for (ClientObjectProxy<ClientObject> proxy : new ClientObjectProxyContainer<ClientObject>().getProxies()) {
//Do something...
}
// Loop 4
// Compiler fails on next code line
// incompatible types
// found : java.lang.Object
// required: GenericForumsExample.ClientObjectProxy
for (ClientObjectProxy proxy : proxyContainer.getProxies()) {
//Do something...
}
}
}
In code dealing with generics, try to avoid using raw types at all. When you use these types, you will often loose more type-information than you expect, as is happening in this case.
The call
proxyContainer.getProxies()
in the last loop returns actually aList
(becauseproxyContainer
is of a raw type, all generics relating to its type are removed, including generics in method signatures). And if you iterate over a rawList
, you will only getObject
s out of it, so there is a compile error. You can resolve this by writing(List<ClientObjectProxy>)proxyContainer.getProxies()
in the for loop (you will get a warning of course).Thus it is usually clearer to use wildcards instead of raw types. In code which is already "genericified", never use the raw type
ClientObjectProxyContainer
, but alwaysClientObjectProxyContainer<?>
, if you don't have a concrete type. This type has basically the same meaning, but it will not lead to all generic types being ignored when it is used.When using the wildcard for the type of
proxyContainer
, the result type ofgetProxies()
will beList<ClientProxyObject<?>>
instead of justList
, so you can takeClientProxyObject
s out of it (but here, too, prefer to useClientProxyObject<?>
!).