CODEWITHSUNDEEP
javaclonecompiler-warnings
Albert
Albert

Reputation: 68140

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

This code:

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

gives me this warning:

Type safety: Unchecked cast from Object to Stack<Utils.OperatorTree.RawStringIterator.State>

I guess I can ignore the warning here. But I wonder about how to use clone() in general? Do I always have to use a @SuppressWarnings("unchecked") every time I use clone()? Or should I always do the completely redundant extra check?

Upvotes: 4

Views: 8659

Answers (4)

P&#233;ter T&#246;r&#246;k
P&#233;ter T&#246;r&#246;k

Reputation: 116266

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.

Upvotes: 13

Grodriguez
Grodriguez

Reputation: 21995

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.

Upvotes: 0

Bozho
Bozho

Reputation: 597076

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.

Upvotes: 2

dty
dty

Reputation: 18998

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!)

Upvotes: 0

Related Questions