How do you make a generic abstract function that does not return any particular type?

At the moment, I have a superclass called Entity.

abstract class Entity {
    private String name;
    private Area area;

    public Entity(String name, Area area) {
        this.name = name;
        this.area = area;
    }

    private static void entityWait() {
        Time.sleep(Random.nextInt(50, 600));
    }

    private String getName() {
        return name;
    }

    private Area getArea() {
        return area;
    }

    abstract <T> T getNearest();

    abstract boolean validate();


}

As far as I understand, this indicates that T is a generic and the return type can be set to anything.

abstract <T> T getNearest();

I then have my subclass in which I extend from Entity:

public class Mob extends Entity {

private String name;
private Area area;

public Mob(String name, Area area) {
    super(name, area);
}

@Override
Npc getNearest() {
    Npc npc = Npcs.getNearest(name);
    return npc;
}

Eventually, I will have a SceneObject and Item class which refers to items in the game world which will require the same functions. So, eventually I'll have to do in the SceneObject class:

@Override
SceneObject getNearest() {
    SceneObject object = SceneObjects.getNearest(name);
    return object;
}

However, I'm getting an unchecked override warning - return type requires unchecked conversion. What does this mean and how do I do this the correct way?

You want to declare Entity itself as generic:

abstract class Entity<T> {
    private String name;

    ...

    abstract T getNearest();

    ...
}

Then your extending class uses the generic parameter:

public class Mob extends Entity<Npc> {

    ...

    @Override
    Npc getNearest() {
       return Npcs.getNearest(name);
    }

    ...

}

define your Entity class with generic parameters:

abstract class Entity<T> {

And remove the generic type declaration from your method:

abstract T getNearest();

And have your subclass extend Entity with a generic type:

public class Mob extends Entity<Npc> {

What you are trying breaks at least two rules of object oriented programming. You mix class and interface. You expect any subclass of Entity to fulfill an unknown contract to get nearest. If I invoke this method with a type argument of ArrayList<IllegalStateException> the subclass must return this type. How can this be known at compile time?

The second is breaking out of the instance' context of Mob by invoking a static method Npcs.getNearest(name) that does anything…like printing out a sheet of paper on a clerks desk on the other side of the world to get nearest Npc. That person scans in the result and returns it with a carrier pigeon. An optical character recognition tool then kills the pigeon to extract the characters and returns an Npc, or null or a Runtime Exception or OutOfMemoryError.

I assume you thought about a contract like expressed through an interface and the method getNearest returns something, that is determined by the realizer of the method. Thus you need interfaces instead of classes. And it is also unclear, whether there can be a superposition of two different getNearest in the same class.

Maybe it is absolutely sufficient to let SceneObject have a getNearest of its own as well as Mob and not force this through the Entity. Otherwise getNearest ought to return something that bears a distance to its source or even any source, so getNearest of SceneObject can be compared to getNearest of Mob – what your contract suggests. If this is never the case, drop all evil inheritance.