Difference between Abstract Class and Interface in Java

Message Content:
Hi everyone,
I am currently learning Java and I am confused about the difference between an abstract class and an interface.
From what I understand:
An abstract class can have both abstract and non-abstract methods.
An interface contains only abstract methods (but I read that from Java 8 it can also have default and static methods).
Here is a small example:
abstract class Animal {    abstract void sound();        void sleep() {        System.out.println("Sleeping...");    } } interface Pet {    void play(); } class Dog extends Animal implements Pet {    void sound() {        System.out.println("Bark");    }    public void play() {        System.out.println("Dog is playing");    } }
My doubts are:
When should I use an abstract class instead of an interface?
Can a class extend multiple abstract classes?
What are the real-time scenarios where interfaces are preferred?
I would appreciate if someone could explain with simple examples.
Thank you!

Naveen Kulanthaivel wrote:. . . When should I use an abstract class instead of an interface?

When you have default functionality you want a limited number of types to implement, then an abstract class is probably better. Example:-abstract class Vehicle {   public void speedUp(int mph)   {      speed += mph;   }   public int speed()   {      return speed;   }All Vehicles have a speed, so you would waqt that as a non‑abstract method. You don't want to instantiate Vehicle directly, so you mark the class abstract.

Can a class extend multiple abstract classes?

No.

What are the real-time scenarios where interfaces are preferred? . .

When you don't know how many implementing types you are likely to have. You might make Engine an interface. I wrote about an Engine interface here.

Having more than one direct base class (abstract or not) is known as multiple  inheritance. The C++ programming language supports multiple inheritance, and it can get very, very messy. Most notably when two or more base classes implement the same method but with conflicting actions.

The designers of Java saw that and that is why Java has Interfaces. They offer the same benefits as multiple inheritance without the mess.

Interestingly, thanks to default methods, we do now have something like multiple inheritance of implementations in Java.  They have a fairly simple fix for the problem Tim references: if there are two or more default implementations for the same method, then a compiler error forces you to explicitly specify how the method should be implemented.  For example:
public class MultipleInterfaceInheritance {  interface Foo {    default void doIt() {      System.out.println("Foo.doIt()");    }  }  interface Bar {    default void doIt() {      System.out.println("Bar.doIt()");    }  }  static class FooBar implements Bar, Foo {} // does not compile    public static void main(String... args) {    var fb = new FooBar();    fb.doIt();  } }
This gives an error message:
java: types MultipleInterfaceInheritance.Bar and MultipleInterfaceInheritance.Foo are incompatible;  class MultipleInterfaceInheritance.FooBar inherits unrelated defaults for doIt() from types MultipleInterfaceInheritance.Bar and MultipleInterfaceInheritance.Foo
This can be fixed by providing an implementation.  If you want to use one of the conflicting default implementations, there's a simple syntax:
 static class FooBar implements Bar, Foo {    public void doIt() {      Bar.super.doIt();  // use the one from Bar    }  }
This now compiles and works fine.