Should I implement all the methods present in an abstract class?

Question

Below is the code snippet:

public abstract class MyAbstractClass {      public abstract void a();     public abstract void b(); }   public class Foo extends MyAbstractClass {      public void a() {         System.out.println("hello");     }      public void b(){         System.out.println("bye");     } }   public class Bar extends MyAbstractClass {      public void a() {         System.out.println("hello");     }      public void delta() {         System.out.println("gamma");     } } 

There are couple of questions that I have:

Q-1 :- Should I implement ALL the methods in abstract class?

Q-2 :- Can the implementing class have its own methods?

Answer 1

When you extend an Interface or an Abstract class you are creating a contract of sorts with that superclass. In the contract you are saying:

"I will implement all unimplemented methods in my superclass"

If you do not, implement all the unimplemented methods, then you are breaking your contract. A way to not break your contract is make your subclass Abstract as well as a way of saying

"I have not implemented all the classes in my contract, I am going to have my subclasses implement them".

For your class bar right now, you must implement b() or make bar an Abstract class or you are not fulfilling your contract with MyAbstractClass

The basic idea is:

Interface: None of my methods are implemented. A subclass must implement all my methods in order to implement me. (Note: I believe default interfaces have been added to Java 8 which may change this a bit)

Example:

 public interface myInterface  {       //My subclasses must implement this to fulfill their contract with me      public void methodA();       //My subclasses must implement this to fulfill their contract with me      public void methodB();  } 

Abstract: I may implement some of my methods, but I will also leave methods as abstract so that my subclasses must implement because they can implement those classes to suit their needs better than I can.

Example:

 public abstract class myAbstractClass  {      //My subclasses must implement this to fulfill their contract with me      public abstract void methodC();       public void helloWorld()      {          System.out.println("Hello World");      }  } 

Abstract classes can also extend interfaces so they can implement some of their methods. But they can also leave some of the methods unimplemented so the subclass can implement them. If you leave an interface method unimplemented, there is not need to declare it abstract, it is already in the contract.

Example:

  public abstract class myAbstractClass2 implement myInterface   {       @Override       public void methodA()       {           // this fulfills part of the contract with myInterface.           // my subclasses will not need to implement this unless they want to override           // my implementation.       }        //My subclasses must implement this to fulfill their contract with me       public abstract void methodD();   } 

So in essence, an abstract class doesn't have as strict a contract with it's superclass because it can delegate its methods to its subclasses.

Regular Class: (I use regular to mean non-interface, and non-abstract). I must implement all unimplemented methods from all of my superclasses. These classes have a binding contract.

Example:

 public class mySubClass extends myAbstractClass2  {      @Override      public void methodB()      {          //must be implemented to fulfill contract with myInterface      }       @Override      public void methodD()      {          //must be implemented to fulfill contract with myAbstractClass2      }       public void myMethod()      {         //This is a method specifically for mySubClass.       }  } 

Answer 2

Q-1:- Should I implement all methods in abstract class?

• Yes, you must implement all abstract methods.

Q-2 :- Can the implementing class have its own methods?

• Yes, you can declare own (more specfic) methods.