Seems, that you have only instances of the Specific class in your
Collection, if you know, that every one can be cast to it. therfore I would
use a Collection of your Specific type. As lang as you do not cast (after
test with instanceof) you cannot use the specific /new/ methods.

Another thing:
Everything, that gets overloaded is useable, because the abstract class
provides the need to implement it. Because you cannot make instances of an
akstract class, in your collection are only non abstract classes with the
abstract as superclass. So you have valid objects, with an implementation
of your method. so there should be no need to cast - but I did not test
that case.

Greetings,
  Tim

How about this?

for(Generic oGeneric : genericCollection) {
  Specific o = (Specific)oGeneric;
  // do stuff using o
}

Patricia

I suggest you really make sure whether you can change it or not. If you
are using generics, casts often mean design issues.

You can quite easily make a "safe" casting iterator.

    /**
      * <strong>{see Iterator#next}
      *    will throw ClassCastException...</strong>
      */
    public static <T> Iterable<T> castIterable(
        final Class<T> clazz, final Iterable<? super T> iterable
    ) {
        return new Iterable<T>() {
            public java.util.Iterator<T> iterator() {
                return new java.util.Iterator<T>() {
                    private final java.util.Iterator<? super T> target =
                        iterable.iterator();
                    public boolean hasNext() {
                        return target.hasNext();
                    }
                    public T next() {
                        return clazz.cast(target.next());
                    }
                    public void remove() {
                        target.remove();
                    }
                };
            }
        };
    }

...
        for (Specific thing : castIterable(Specific.class, generals)) {

(Disclaimer: Not tested.)

Tom Hawtin