Classes that are entirely abstract (all methods are abstract) are (almost) the same as interfaces (the major difference being they can contain fields and non-public abstract methods, which interfaces cannot). The difference is when you have an abstract class which contains a method which has some common functionality which will be the same for all derived children.

If you want to model a Filesystem, for example, you know that, regardless of the object type, you will have a path for an item. You'd want to have a common implementation for getting that path (no point in writing the same thing over and over again), and leave anything special for the children to implement.

An abstract class is a class that has some methods implemented and some not (well, generally true). When you subclass (or extend) an abstract class you are required to implement all the abstract methods (or mark yourself as abstract) and may choose to override any of the implemented methods. When subclassing (or implementing) and interface you are required to implement all the methods (or, again, mark yourself abstract).

An abstract class is useful when a group of things all perform very similar functions except for a few methods. That way you don't have to repeat the implementation that is common among them.

Here, Something about abstract class...

1. Abstract class is an incomplete class so we can't instantiate it.
2. If methods are abstract, class must be abstract.
3. In abstract class, we use abstract and concrete method both.
4. It is illegal to define a class abstract and final both.

Real time example--

If you want to make a new car(WagonX) in which all the another car's properties are included like color,size, engine etc.and you want to add some another features like model,baseEngine in your car.Then simply you create a abstract class WagonX where you use all the predefined functionality as abstract and another functionalities are concrete, which is is defined by you.
Another sub class which extend the abstract class WagonX,By default it also access the abstract methods which is instantiated in abstract class.SubClasses also access the concrete methods by creating the subclass's object.
For reusability the code, the developers use abstract class mostly.

abstract class WagonX
{
   public abstract void model();
   public abstract void color();
   public static void baseEngine()
    {
     // your logic here
    }
   public static void size()
   {
   // logic here
   }
}
class Car extends WagonX
{
public void model()
{
// logic here
}
public void color()
{
// logic here
}
}

One of the key differences between an abstract class and a non-abstract class is the fact that you cannot create an instance of an abstract class. This prevents a situation where a method with no definition gets called.

So if we had the following abstract class:

abstract class Elephant {    // abstract class

    public String getName() {
        return "Ollie";
    }

    public abstract void walk();   // abstract method

}

Then the following would be illegal:

Elephant e = new Elephant();   // error

Because Elephant is abstract and it cannot be instantiated.

But say for argument sake, that we make Elephant non-abstract but it is allowed to still have the abstract method walk(). i.e. we change the definition of Elephant to:

class Elephant {    // non-abstract class

    public String getName() {
        return "Ollie";
    }

    public abstract void walk();    // abstract method

}

Now what should happen if I do the following:

Elephant e = new Elephant();   // legal since Elephant is non-abstract
e.walk();   // oops, we didn't define this anywhere

Java compiler won't allow this. You could argue that there are other ways to handle a situation like this, but this simply how the Java language has decided to implement the feature.