Abstract class with all methods abstract - Practical Example

As well as for holding state, it's worth remembering that all interface members are implicitly public. So restricting visibility of abstract methods may itself be a compelling enough reason to use an abstract class instead of an interface.

1. Adding to the two answers given above, Interfaces can only have constants(Variables which are public,static and final) while there is no such restrictions for abstract classes.

2. Abstract classes can have constructors which will be implicitly called when a child class is instantiated (if it is non-parameterised). But this is not possible with interfaces.

Here is an example for the usage of an abstract class

abstract class Animal{ public int noOfLegs; public boolean isAlive; Animal(){ isAlive = true; } public abstract void walk(); } class Cow extends Animal{ Cow(){ noOfLegs = 4; } public void walk(){ if(isAlive){ //Code for walking } } } 

One other general purpose of an abstract class is to prevent an instance of the class., for example

 abstract class Mammal{ int i=0; } public class Man extends Mammal{ public setMeValue(int i){ this.i=i; } public static void main(String args[]){ Mammal m= new Man(); man.setMeValue(10); } } 

In the above code, I effectively make sure that there will never be an object of instance Mammal.

An interface can be applied to wildly different classes. Classes that have no relation to each other are Serializable or Cloneable. However, subclasses of an abstract class are all related. This may not mean anything when implementing the interface or extending the abstract class, but it means something semantically.

There is a style of programming where all the methods of a base class are either public final, protected abstract, protected and empty, or private. But even that isn't what the OP was interested in.

Adding more to the below answers:

Interface provide you with a contract to implement where abstract Class may provide you with a template as well. For a simple scenario you can use an Interface or an abstract Class without thinking much. But having an abstract class just for maintaining a state might give you lot of problems in a complex implementation. In such cases you have to carefully consider what you really want to achieve in your code and make the decision. If you consider the case of maintaining the state in your code, you can always use the State pattern in your implementation, so you will be able to use an interface in your code. You should always consider the extend-ability and maintainability of your code before deciding to use an abstract class over interface.

The simplest practical example I can think of is a class that has a protected variable:

public abstract class RoadVehicle { protected int numberOfTires; protected String vinNumber; protected VehicleRegistration registration; public abstract void drive(); public abstract double calculateToll(); public abstract void changeTires(); // so on and so forth... } 

You can't do this with an interface.

public abstract class animal{ public abstract void speak(){ System.out.println("animal voice"); } } public class dog extends animal{ public void speak(){ System.out.println("dog voice"); } } 

The biggest motive behind having Pure Abstract classes is to allow future extension. Assume you have an Abstract class (with all abstract members), then you inherit that abstract class in 20 derived classes. Sometime in future you wish to add a public method to 5 of your derived classes, what do you do ?

Since you already inherit the abstract class, an easier solution is to add the method (with implementation) to the abstract class. This way you don't have to touch any of the derived classes. Interfaces are very rigid in this context, once created there is very little chance to change an Interface, as it would require changing all the classes that implement that Interface.