Abstract methods means there is no default implementation for it and an implementing class will provide the details.

Essentially, you would have

abstract class AbstractObject {
   public abstract void method();
}

class ImplementingObject extends AbstractObject {
  public void method() {
    doSomething();
  }
}

So, it's exactly as the error states: your abstract method can not have a body.

There's a full tutorial on Oracle's site at: http://download.oracle.com/javase/tutorial/java/IandI/abstract.html

The reason you would do something like this is if multiple objects can share some behavior, but not all behavior.

A very simple example would be shapes:

You can have a generic graphic object, which knows how to reposition itself, but the implementing classes will actually draw themselves.

(This is taken from the site I linked above)

abstract class GraphicObject {
    int x, y;
    ...
    void moveTo(int newX, int newY) {
        ...
    }
    abstract void draw();
    abstract void resize();
}

class Circle extends GraphicObject {
    void draw() {
        ...
    }
    void resize() {
        ...
    }
}
class Rectangle extends GraphicObject {
    void draw() {
        ...
    }
    void resize() {
        ...
    }
}

If I understand your question correctly, Yes.

public abstract class TopClass {
  public abstract void methodA();
  public abstract void methodB();
}

public abstract class ClassA extends TopClass {
  @Override
  public void methodA() {
    // Implementation
  }
}

public class ClassB extends ClassA {
  @Override
  public void methodB() {
    // Implementation
  }
}

In this example, ClassB will compile. It will use it's own implementation of methodB(), and ClassA's implementation of methodA(). You could also override methodA() in ClassB if desired.

- Abstract class is one which can't be instantiated, i.e. its object cannot be created.

- Abstract method are method's declaration without its definition.

- A Non-abstract class can only have Non-abstract methods.

- An Abstract class can have both the Non-abstract as well as Abstract methods.

- If the Class has an Abstract method then the class must also be Abstract.

- An Abstract method must be implemented by the very first Non-Abstract sub-class.

- Abstract class in Design patterns are used to encapsulate the behaviors that keeps changing.

One of the most obvious uses of abstract methods is letting the abstract class call them from an implementation of other methods.

Here is an example:

class AbstractToy {
    protected abstract String getName();
    protected abstract String getSize();
    public String getDescription() {
        return "This is a really "+getSize()+" "+getName();
    }
}
class ToyBear extends AbstractToy {
    protected override String getName() { return "bear"; }
    protected override String getSize() { return "big"; }
}
class ToyPenguin extends AbstractToy {
    protected override String getName() { return "penguin"; }
    protected override String getSize() { return "tiny"; }
}

Note how AbstractToy's implementation of getDescription is able to call getName and getSize, even though the definitions are in the subclasses. This is an instance of a well-known design pattern called Template Method.

Basically you want, if possible, to use interfaces wherever possible. The only difference between an interface and an abstract class, aside from classes only being able to extend one class, is that abstract classes can contain state. If you don't need to contain state it's better to use interfaces since a class can implement any number of interfaces.

So to answer your question:

It seems interfaces can do all that abstract classes can do but better.

No. Abstract classes can contain state, interfaces can't.

An example for using interfaces, abstract classes and concrete classes:

public interface UserDb {
    void storeUser(User user);
    default void storeUsers(User... users) {
        for(User u : users) {
            storeUser(u);
        }
    }
}

public abtract class AbstractUserDb implements UserDb {
    protected List<User> users = new ArrayList<>();

    @Override
    public void storeUser(User u) {
        users.add(u);
    }
}

public class JsonUserDb extends AbstractUserDb {
    @Override
    public void storeUser(User u) {
        super.storeUser(u);
        new ObjectMapper().writeValue(users, "users.json");
    }
}

An abstract method is a method without a body. So you can't just call an abstract method of an abstract class (you cannot instantiate an abstract class directly). If you want to have your abstract game class with the abstract methods you need to have a class that extends this game class and specifically implements these methods without the abstract keyword.

Or you remove the abstract keyword from init and render and then the subclass of your Game class doesn't have to implement these methods but will take the one defined in your Game class.

Alternatively you can remove the abstract keyword from the methods in your game class but still @Override them in your subclass. That way you can define a default behavior for init and render and still change it in a subclass if needed.

public abstract class Game {

    public Game() {};

    public void init()
    {
        // do init stuff
    }

    public void render()
    {
        // do render stuff
    }
}




public class specificGame extends Game {

    public specificGame() {};

    // no need to implement init and render. But you can still override them

    @Override
    public void init()
    {
        // spefic init stuff
    }

    @Override
    public void render()
    {
        // specific render stuff
    }

}

More about abstract classes and methods https://docs.oracle.com/javase/tutorial/java/IandI/abstract.html

Is this what you want?

This is the main file:

package devex;

import devex.SubClass;

public class MainClass
{

    public static void main(String[] args)
    {
        SubClass.init();
        AClass.init();
    }
}

The this is the abstract class defining a default init

package devex;

public abstract class AClass
{

    public static void init() 
    {
        System.out.println("AClass init");
    }

}

This subclass extends AClass and overwrites init

package devex;

public class SubClass extends AClass
{

    public static void init()
    {
        System.out.println("Subclass init");
    }

}