Weird final value lost glitch

Question

Forgive me for pasting the raw code, rather than narrowing it down to a simple test case, but all things considered, I don't think a test case is needed to analyze something this simple:
public static final class CandidateDepthDataIterator<T> extends ConversionIterator<Candidate,T>
     private final Class<T> ct;
     private final int depth;
     public CandidateDepthDataIterator(Iterator<CandidateBin> i, Class<T> t, int depth)
          super(new CandidateIterator(i));
          ct = t;
          System.out.println("Ctor " + depth);
          this.depth = depth;
     @Override
     protected T convert(Candidate c)
          System.out.println(c.depth + " = " + depth);
          return ct.isInstance(c.data) && c.depth == depth ? ct.cast(c.data) : null;
     }The above code prints:
Ctor 10
0 = 0
I don't have a clue why it's doing that. I was hoping someone here might be able to fill me in on why it's doing that.
For those of you still wondering what's going on, notice the "final int depth". It is marked as final, so whatever value it is assigned at constructor time, as I understand it, it should never change from that value. Yet, as you can see from the print statements, it has value of 10 at construction time, and value of 0 at the time of the call to validate(). Somehow, well beyond my comprehension, the value of a final int has changed.
So why is it doing that? How do I make it stop doing that and stick with the value that I give it (10)?

Answer 1

That is the complete code for that class. I'll also share the code for the superclass.
      * Abstract Iterator wrapper/implementation which allows the individual elements
      * to be converted or even bypassed as needed (by having convert() return null).
      * This implementation will not return null elements.
      * <p>
      * Note that due to the way this iterator is implemented,
      * dynamic removal of elements is not possible.
      * @param <T1> The type of the wrapped iterator.
      * @param <T2> The output (converted) type of the implementation iterator.
     public static abstract class ConversionIterator<T1, T2> implements Iterator<T2>
          /** The wrapped iterator */
          protected final Iterator<T1> iter;
          /** Stores the next element that was able to convert */
          protected T2 next;
           * Wraps the given iterator, and prepares the first converted element.
           * @param t1
          public ConversionIterator(Iterator<T1> t1)
               iter = t1;
               next = findNext();
          public boolean hasNext()
               return next != null;
          public T2 next()
               if (next == null) throw new NoSuchElementException();
               T2 n = next;
               next = findNext();
               return n;
          public void remove()
               // Simply doing ci.remove() here wouldn't work if hasNext has been called.
               throw new UnsupportedOperationException();
           * Prepares the next available converted element for iteration.
           * @return The converted element.
          private T2 findNext()
               while (iter.hasNext())
                    T1 c = iter.next();
                    T2 r = convert(c);
                    if (r != null) return r;
               return null;
           * Converts a given element into the implementation type.
           * Implementations may return null to entirely skip the element.
           * The implementation iterator will skip to the next non-null conversion.
           * @param c An element from the wrapped iterator.
           * @return A converted element for the implementation iterator, or null.
          protected abstract T2 convert(T1 c);
          }I don't see anything in there that should affect it at all.