Some generic anonymous class overriding methods compile, while others don't

Question

I have the following (stripped-down) code. The abstract class SessionHandler<T> is used by other code to define and run an operation that needs a session to something. This is best done in my code with anonymous classes, because of the shear number of operations defined. In the EntityOps<T> class, these work great. But, in the last class shown here, SomeClass, the anonymous class definition fails, though the semantics are almost identical. (List<T> vs.List<AnotherClass>) What am I doing wrong here? Or is this a bug in Java?
Thanks, Tom
public interface IEntityOps<T> {
    T get();
    List<t> getAll();
public abstract class SessionHandler<T> {
    abstract T handle(Session session) throws Throwable;
    public final T perform() {
        ... calls handle(session) ...
// These anonymous class definitions compile fine!
public class EntityOps<T> implements IEntityOps<T> {
    public T get() {
        T ret = null;
        ret = new SessionHandler<T>() {
            T handle(Session s) throws Throwable {
                T ret = (some T object calculation);
                return ret;
        }.perform();
        return ret;
    public List<T> getAll() {
        T ret = null;
        return new SessionHandler<List<T>>() {
            List<T> handle(Session s) throws Throwable {
                List<T> ret = (some List<T> calculation);
                return ret;
        }.perform();
// This anonymous class definition fails with the error:
// "SomeClass.java": <anonymous someMethod> is not abstract and does not override abstract method handle()
//     in SessionHandler at line XX, column XX
public class SomeClass {
    public List<AnotherClass> someMethod() throws {
        List<AnotherClass> ret = null;
        ret = new SessionHandler<List<AnotherClass>>() {
            List<AnotherClass> handle(Session s) throws Throwable {
                List<AnotherClass> ret = (some List<AnotherClass> calculation);
                return ret;
        }.perform();
        return ret;
}

Answer 1

I added @Override above the abstract method override, and it provides this additional error:
"HousingConfigImpl.java": method does not override a method from its superclass at line 382, column 17
I have also reconstructed the code layout in a separate set of classes that have no dependancies, but there's no error coming from these!
public class CustomThing {
public interface ISomeInterface<T> {
    List<T> interfaceMethod();
public abstract class SomeAbstractClass<T> {
    private Class _c = null;
    public SomeAbstractClass(Class c) {
        _c = c;
    protected Class getC() {
        return _c;
    public abstract T methodToOverride(Object neededObject) throws Throwable;
    public final T finalMethod() {
        try {
            return methodToOverride(new Object());
        } catch(Throwable e) {
            throw new RuntimeException(e);
import java.util.List;
import java.util.Collections;
public class SomeInterfaceImpl<T> implements ISomeInterface<T> {
    public List<T> interfaceMethod() {
        return new SomeAbstractClass<List<T>>(CustomThing.class) {
            public List<T> methodToOverride(Object neededObject) throws Throwable {
                return Collections.emptyList();
        }.finalMethod();
import java.util.Collections;
import java.util.List;
public class SomeOtherClass {
    public List<CustomThing> someMethod() {
        return new SomeAbstractClass<List<CustomThing>>(CustomThing.class) {
            public List<CustomThing> methodToOverride(Object neededObject) throws Throwable {
                return Collections.emptyList();
        }.finalMethod();
}So, there's something about my code that causes it to be, somehow, different enough from the example provided above so that I get the error. The only differences in the override method definitions in my actual code are in the return type, but those are different in the example above as well. Here are the class declarations, anonymous abstract class creation statements, and abstract method declarations from the actual code.
public abstract class SessionHandler<T> {
    abstract T handle(Session session) throws Throwable;
public class EntityOps<T> implements IEntityOps<T> {
            return new SessionHandler<List<T>>(_mgr, _c, "getAll" + _c.getName()) {
                List<T> handle(Session s) throws Throwable {
public class HousingConfigImpl implements IHousingConfigOperations, ISessionFactoryManager {
            ret = new SessionHandler<List<Tenant>>((ISessionFactoryManager)this, Housing.class, "getTenantsInNeighborhood") {
                List<Housing> handle(Session s) throws Throwable {I can't for the life of me see any syntactical difference between my example and the real code. But, one works and the other doesn't.