java is it bad to declare a variable of type E (generics)

I'm looking at an example implementation of a linkedlist consisting of nodes. The set method goes to the input index a开发者_运维问答nd sets the value equal to the input value. Additionally, it returns the old value. When he retrieves the old value he always creates a new node object instead of an object of type E. Is that necessary or is that considered good practice? Also are there any efficiency considerations? Example code below

public E set(int idx, E newVal){

    //looping code to get to the right node
    //Assume variable finger is now a Node object that's at the right index

    Node<E> temp = new Node<E>(finger);
    finger.setValue(newVal);
    return temp.getValue();

    //Can I do the following instead?
    E temp = finger.getValue();
    finger.setValue(newVal);
    return temp;

 } 

No, it's perfectly acceptable to use the generic type parameter (E in this case). There's nothing wrong with your second code sample.

According to the Generics FAQ:

Can I use a type parameter like a type?

No, a type parameter is not a type in the regular sense (different from a regular type such as a non-generic class or interface).

Type parameters can be used for typing (like non-generic classes and interfaces)::

• as argument and return types of methods
• as type of a field or local reference variable
• as type argument of other parameterized types
• as target type in casts
• as explicit type argument of parameterized methods

Type parameters can NOT be used for the following purposes (different from non-generic classes and interfaces)::

• for creation of objects
• for creation of arrays
• in exception handling
• in static context
• in instanceof expressions
• as supertypes
• in a class literal

Assuming that setValue() and getValue() modify the same attribute, the first 3 lines of code will return newVal (they don't make much sense)

temp is a reference to finger, so if you set a new value to an attribute in finger, then it will change in temp.

The last three lines don't have the same behavior, since they return the previous value.

That impl is quite odd. It probably was translated from a C++ impl

Node<E> temp = finger; // C++, copy constructor, default is shallow copy
finger.setValue(newVal);
return temp.getValue();

That would be very cheap for C++.