java: how to use clone() and what about the cast check

Question

This code:

class RawStringIterator {
        java.util.Stack stateStack = new java.util.Stack();
        RawStringIterator(RawStrin         


        

Answer 1

You have very little choice but to ignore it.

Whilst not directly relevant (because you're not writing a clone() method), this entry in the Java Generics FAQ makes good reading (as does the whole FAQ!)

Answer 2

There is no way to avoid the cast here. clone() returns Object, if it is java.util.Stack, it is not making use of co-variant return types.

If this is not java.util.Stack, then don't implement clone() - it's really hard to get it right. Make a copy-constructor instead.

Answer 3

If you have the choice, the best is not to implement / use clone() at all, because it is a broken API. Just implement / use a copy constructor instead.

If for some pressing reason you must use clone() but can change its implementation, consider declaring Stack<T>.clone() to return Stack<T> instead of Object - covariant return types are legal since Java5.

Update: if the Stack in question is java.util.Stack, consider its Javadoc:

A more complete and consistent set of LIFO stack operations is provided by the Deque interface and its implementations, which should be used in preference to this class.

And e.g. ArrayDeque provides a copy constructor.

Answer 4

Yes, you'll need to explicitly suppress the warnings each time you use clone().

This is one of the reasons you might prefer to use copy constructors instead of clone(), if available.

By the way in your code, when the RawStringIterator(RawStringIterator i) constructor is used, the first initialisation of stateStack is unnecessary:

class RawStringIterator {
    Stack<State> stateStack = new Stack<State>();
    RawStringIterator(RawStringIterator i) {
          stateStack = (Stack<State>) i.stateStack.clone();
    }
    /* ... */
}

You might want to remove that.