Question

Abstract classes and interfaces play very a important role in Java and they have their own importance in certain situations. They possess certain special characteristics. There are some observable differences between them. Let me describe some a few of them.

---

One of the major differences between an interface and an abstract class is that an abstract class can never be instantiated, an interface however can.

Both of them can never be declared as final obviously, because they are to be inherited by some other non-abstract class(es).

Both of them can never have static methods. Neither concrete nor abstract (abstract static methods indeed and in fact, don’t exist at all).

An interface can never never have concrete methods (a method with it’s actual implementation), an abstract class however can have concrete methods too.

An interface can not have constructors, an abstract class can however can have.

---

Two obvious questions are likely to arise here.

An abstract class can never be instantiated because it is by nature, not a fully implemented class and it’s full implementation requires it to be inherited by some other non-abstract class(es). If it is so then, an abstract class should not have a constructor of it’s own because a constructor implicitly returns an object of it’s own class and an abstract class by itself can not be instantiated hence, it should not be able to have a constructor of it’s own.

An interface somewhat looks better and more appropriate to use than an abstract class, since it imposes less restrictions than what those are imposed by an abstract class. In which very specific situations, an interface is useful and in which very specific situations, an abstract class is appropriate? Hope! the boldface letters would be taken into much consideration.

Answer 1

First off, you’re factually wrong in a few places:

• One of the major differences between an interface and an abstract class is that an abstract class can never be instantiated, an interface however can.

Wrong. An abstract and interface can both be instantiated anonymously.

• Both of them can never be declared as final obviously, because they are to be inherited by some other non-abstract class(es).

True, although I personally see no reason why interfaces couldn’t have been able to be final so they couldn’t be extended, but that’s just me. I see why they made the decision they did.

• Both of them can never have static methods. Neither concrete nor abstract (abstract static methods indeed and in fact, don’t exist at all).

Abstract classes can have static methods; sorry!

• An interface can never never have concrete methods (a method with it’s actual implementation), an abstract class however can have concrete methods too.

Yes, that’s one of the the primary differences between them.

• An interface can not have constructors, an abstract class can however can have.

Yes, that’s true.

Now, let’s move on to your questions:

Your first paragraph doesn’t have a question in it. What was the question there? If it was “Why allow abstract classes to have constructors if you can’t instantiate them?” the answer is so child classes can use it. Here’s an example

abstract class Parent {
    String name;
    int id;
    public Parent(String n, int i) { name = n; id = i; }
}

class Child extends Parent {
    float foo;
    public Child(String n, int i, float f) {
        super(n,i);
        foo = f;
    }
}

// later
Parent p = new Parent("bob",12); // error
Child c = new Child("bob",12); // fine!

Your second paragraph has a question but is malformed. I think you’re simply missing an ‘is’ in there… 🙂 The answer to it is as follows:

You use an interface when you want to define a contract. Here’s a very specific example:

public interface Set<E> {
    int size(); // determine size of the set
    boolean isEmpty(); // determine if the set is empty or not
    void add(E data); // add to the set
    boolean remove(E data); // remove from the set
    boolean contains(E data); // determine if set holds something
}

Four common methods to all sets.

You use an abstract class when you want to define SOME of the behavior, but still have the contract

public abstract class AbstractSet<E> implements Set<E> {
   // we define the implementation for isEmpty by saying it means
   // size is 0
   public boolean isEmpty() { return this.size() == 0; }
   // let all the other methods be determined by the implementer
}