I'm having some trouble navigating Java's rule for inferring generic type parameters. Consider the following class, which has an optional list parameter:

import java.util.Collecti


I'm having some trouble navigating Java's rule for inferring generic type parameters. Consider the following class, which has an optional list parameter:
My Java compiler gives the following error:
But Collections.emptyList() returns type <T> List<T>, not List<Object>. Adding a cast doesn't help
yields
Using EMPTY_LIST instead of emptyList()
yields
Whereas the following change makes the error go away:
Can anyone explain what type-checking rule I'm running up against here, and the best way to work around it? In this example, the final code example is satisfactory, but with larger classes, I'd like to be able to write methods following this "optional parameter" pattern without duplicating code.
For extra credit: when is it appropriate to use EMPTY_LIST as opposed to emptyList()?




An alternative to the Dictionary/Config File approach would be 

1) to define a interface for each of the transaction editors. 

2) In your EXE or UI assembly have each of the forms register itself with the assembly that creates the individual transaction. 

3) The class controlling the registration should be a singleton so you don't have multiple form instances floating around. 

3) When a individual transaction is created it pulls out the correct form variable from the registration object and assigns it do an internal variable.

4) When the Edit method is called it just uses the Show method of the internal method to start the chain of calls that will result in the display of that transacton editor. 

This eliminates the need for config files and dictionaries. It continues to separate the UI from the object. Plus you don't need any switch statement

The downside is having to write the interface for each every form in addition to the form itself.

If you have a great deal of different types of editors (dozens) then in that case I recommend that you use the Command Pattern

You have a master command that contains the dictonary recommend by Jonathan. That commands in turns will use that dictornary to execute one of a number of other command that calls the correct form with the correct object. The forms continue to be separate from the object themselves. The forms reside in the Command assembly. In addition you don't have to update the EXE to add another editor only the Command assembly. Finally by putting things inside of Command you can implement Undo/Redo a lot easier. (Implement a Unexecute as well as a Execute)

        

            

javagenericstype-inference