Skip to main content

Interfaces - Need to know:

What is an Interface?

An Interface is like a class in that it can have methods and variables. However, methods declared in an Interface are abstract by default, meaning they only contain the method signature, not the method body.


Facts about Interfaces:

  • Interfaces specify what the class must do and not how the class must do it. They are considered as the class blueprint.
  • If a class implements an interface, the class must provide all the method bodies for the interface's functions. Otherwise, the class must be declared abstract.
  • They are used to achieve total abstraction.
  • An Interface can extend one or many Interfaces. A class can extend many Interfaces, but only one class.
  • Nested Interfaces is when an Interface is declared inside another interface.
  • It is also used to achieve loose coupling.
  • Interfaces are used to implement abstraction. 


Difference between Abstract Class and Interface:

Differences between an Abstract class and an Interface include:

  1. An interface can have strictly abstract methods. In comparison, an abstract class can have abstract and non-abstract methods. 
  2. An abstract class doesn't support multiple inheritances, whereas an interface does.
  3. Interface variables are only static and final. In contrast, an abstract class can have final, non-final, static and non-static variables.  
  4. An abstract class can provide the implementation of an interface. However, an Interface can't provide the implementation of an abstract class.
  5. The interface keyword declares an interface, and the abstract keyword declares an abstract class.
  6. An interface can only extend another Java interface. However, an abstract class can extend another Java class as well as implement multiple Java interfaces.
  7. The interface can be implemented using the keyword "implements". The abstract class can be extended using the keyword "extends". 

Can you declare a constructor inside an Interface?

No, you cannot have a constructor within an interface in Java. A Constructor initializes the non-static members of a particular class concerning an object, therefore:

  • You can only have public, static, final variables and abstract methods.
  • An interface doesn't have a constructor because all data members in an interface are public static final by default. They are constants.
  • The interface has no data members that the constructor can initialize.
  • To call a method, we need an object. Since the interface methods don't have a body, there is no need for calling the methods in an interface.
  • Since we cannot call the interface methods, there is no need to create an object for an interface, and there is no need to have a constructor.


Popular posts from this blog

Executer vs ExecuterSevice: What's the Difference?

Executer and ExcuterService: Executor and ExecutorService are part of Java's Executor framework, which provides  thread pool  facilities to Java applications. Since creating and managing Threads are expensive, It's a better idea to create a thread pool that can execute in parallel rather than every time a new thread is requested, helping reduce the load. This improves the response time of the application. Differences between Executer and ExecuterService: One of the key differences between the Executor and ExecutorService interface is that the former is a parent interface while ExecutorService extends Executor.  A second significant difference between ExecutorService and Executor is that Executor defines an execute() method, which accepts the Runnable interface object. Simultaneously, a submit() method takes both Runnable and Callable object interfaces. Another difference between Executor and ExecutorService interface is that the execute() methods' return type is void, wh...
Read more

Atomic operation and classes in the Java Concurrency API:

Atomic Operation and Class: An operation is classified as atomic if it is performed as a single unit of work without the possibility of interference from other processes. In the Java language specification, they guarantee that the reading or writing operation is atomic (unless the variable is a long or a double). Variables of type long or double in operations are only atomic if declared with the keyword: volatile. Suppose we assume that  i  is defined as an int. The  i++  (increment) operation is not an atomic operation in Java. This also applies to the other numeric types, e.g. long.  This is because the  i++  operation first reads the value currently stored in  i , and then it adds one to it. However, between the read and the write, the value of  i  might have changed. Since Java 1.5, the java language provides an atomic class with variables such as AtomicInteger or AtomicLong. The class also provides methods like getAndDecrement(), ge...
Read more