Java OOPS-Difference Between Abstract Class and Interface in Java

 

Difference Between Abstract Class and Interface in Java

In this article, we will discuss the difference between Abstract Class and Interface in Java with examples. 

 Abstract Class Interface
1 An abstract class can extend only one class or one abstract class at a time An interface can extend any number of interfaces at a time
2  An abstract class can extend another concrete (regular) class or abstract class An interface can only extend another interface
3 An abstract class can have both abstract and concrete methods An interface can have only abstract methods
4 In abstract class keyword “abstract” is mandatory to declare a method as an abstract In an interface keyword “abstract” is optional to declare a method as an abstract
5 An abstract class can have protected and public abstract methods An interface can have only have public abstract methods
6 An abstract class can have static, final or static final variable with any access specifier interface can only have public static final (constant) variable

Each of the above mentioned points are explained with an example below:

Abstract class vs interface in Java

Difference No.1: Abstract class can extend only one class or one abstract class at a time

class Example1{
   public void display1(){
      System.out.println("display1 method");
   }
}
abstract class Example2{
   public void display2(){
      System.out.println("display2 method");
   }
}
abstract class Example3 extends Example1{
   abstract void display3();
}
class Example4 extends Example3{
   public void display3(){
      System.out.println("display3 method");
   }
}
class Demo{
   public static void main(String args[]){
       Example4 obj=new Example4();
       obj.display3();
   }
}

Output:

display3 method

Interface can extend any number of interfaces at a time

//first interface
interface Example1{
    public void display1();
}
//second interface
interface Example2 {
    public void display2();
}
//This interface is extending both the above interfaces
interface Example3 extends Example1,Example2{
}
class Example4 implements Example3{
    public void display1(){
        System.out.println("display2 method");
    }
    public void display2(){
        System.out.println("display3 method");
    }
}
class Demo{
    public static void main(String args[]){
        Example4 obj=new Example4();
        obj.display1();
    }
}

Output:

display2 method

Difference No.2: Abstract class can be extended(inherited) by a class or an abstract class

class Example1{
   public void display1(){
      System.out.println("display1 method");
   }
}
abstract class Example2{
   public void display2(){
       System.out.println("display2 method");
   }
}
abstract class Example3 extends Example2{
   abstract void display3();
}
class Example4 extends Example3{
   public void display2(){
       System.out.println("Example4-display2 method");
   }
   public void display3(){
       System.out.println("display3 method");
   }
}
class Demo{
   public static void main(String args[]){
       Example4 obj=new Example4();
       obj.display2();
   }
}

Output:

Example4-display2 method

Interfaces can be extended only by interfaces. Classes has to implement them instead of extend

interface Example1{
    public void display1();
}
interface Example2 extends Example1{
}
class Example3 implements Example2{
   public void display1(){
      System.out.println("display1 method");
   }
}
class Demo{
   public static void main(String args[]){
      Example3 obj=new Example3();
      obj.display1();
   }
}

Output:

display1 method

Difference No.3: Abstract class can have both abstract and concrete methods

abstract class Example1 {
   abstract void display1();
   public void display2(){
     System.out.println("display2 method");
   }
}
class Example2 extends Example1{
   public void display1(){
      System.out.println("display1 method");
   }
}
class Demo{
   public static void main(String args[]){
     Example2 obj=new Example2();
     obj.display1();
   }
}

Interface can only have abstract methods, they cannot have concrete methods

interface Example1{
   public abstract void display1();
}
class Example2 implements Example1{
   public void display1(){
      System.out.println("display1 method");
   }
}
class Demo{
   public static void main(String args[]){
      Example2 obj=new Example2();
      obj.display1();
   }
}

Output:

display1 method

Difference No.4: In abstract class, the keyword ‘abstract’ is mandatory to declare a method as an abstract

abstract class Example1{
   public abstract void display1();
}

class Example2 extends Example1{
   public void display1(){
      System.out.println("display1 method");
   }
   public void display2(){
      System.out.println("display2 method");
   }
}
class Demo{
   public static void main(String args[]){ 
       Example2 obj=new Example2(); 
       obj.display1();
   }
}

In interfaces, the keyword ‘abstract’ is optional to declare a method as an abstract because all the methods are abstract by default

interface Example1{
    public void display1();
}
class Example2 implements Example1{
    public void display1(){
        System.out.println("display1 method");
    }
    public void display2(){
        System.out.println("display2 method");
    } 
}
class Demo{
   public static void main(String args[]){
       Example2 obj=new Example2();
       obj.display1();
   }
}

Difference No.5: Abstract class can have protected and public abstract methods

abstract class Example1{
   protected abstract void display1();
   public abstract void display2();
   public abstract void display3();
}
class Example2 extends Example1{
   public void display1(){
       System.out.println("display1 method");
   }
   public void display2(){
      System.out.println("display2 method");
   }
   public void display3(){
      System.out.println("display3 method");
   }
}
class Demo{
   public static void main(String args[]){
      Example2 obj=new Example2();
      obj.display1();
   }
}

Interface can have only public abstract methods

interface Example1{
   void display1();
}
class Example2 implements Example1{
   public void display1(){
      System.out.println("display1 method");
   }
   public void display2(){ 
      System.out.println("display2 method");
   }
}
class Demo{
   public static void main(String args[]){
       Example2 obj=new Example2();
       obj.display1();
   }
}

Difference No.6: Abstract class can have static, final or static final variables with any access specifier

abstract class Example1{
   private int numOne=10;
   protected final int numTwo=20;
   public static final int numThree=500;
   public void display1(){
      System.out.println("Num1="+numOne);
   }
}
class Example2 extends Example1{
   public void display2(){
      System.out.println("Num2="+numTwo);
      System.out.println("Num2="+numThree);
   }
}
class Demo{
   public static void main(String args[]){
      Example2 obj=new Example2(); 
      obj.display1();
      obj.display2();
   }
}

Interface can have only public static final (constant) variable

interface Example1{
   int numOne=10;
}
class Example2 implements Example1{
   public void display1(){
      System.out.println("Num1="+numOne);
   }
}
class Demo{
   public static void main(String args[]){
      Example2 obj=new Example2();
      obj.display1();
   }
}

Comments

Post a Comment

Popular posts from this blog

Java OOPS:OOPS Concepts Overview

Image
  OOPs concepts in Java Object-oriented programming System(OOPs) is a programming paradigm based on the concept of “objects” that contain data and methods. The primary purpose of object-oriented programming is to increase the flexibility and maintainability of programs. Object oriented programming brings together data and its behaviour(methods) in a single location(object) makes it easier to understand how a program works. We will cover each and every feature of OOPs in detail so that you won’t face any difficultly understanding  OOPs Concepts . OOPs Concepts – Table of Contents What is an Object What is a class Constructor in Java Object Oriented Programming Features Abstraction Encapsulation Inheritance Polymorphism Abstract Class and Methods Interfaces in Java What is an Object Object:  is a bundle of data and its behaviour(often known as methods). Objects have two characteristics: They have  states  and  behaviors . Examples of states and behaviors Exam...
Read more

Java OOPS:Constructors in Java – A complete study!!

Image
  Constructors in Java – A complete study!! Constructor is a block of code that initializes the newly created object. A constructor resembles an instance method in java but it’s not a method as it doesn’t have a return type. In short constructor and method are different(More on this at the end of this guide). People often refer constructor as special type of method in Java. Constructor has same name as the class and looks like this in a java code. public class MyClass { //This is the constructor MyClass (){ } .. } Note that the constructor name matches with the class name and it doesn’t have a return type. How does a constructor work To understand the working of constructor, lets take an example. lets say we have a class  MyClass . When we create the object of  MyClass  like this: MyClass obj = new MyClass () The  new keyword  here creates the object of class  MyClass  and invokes the constructor to initialize this newly crea...
Read more

Java Basics:Data Types

  Data Types in Java Data types specify the different sizes and values that can be stored in the variable. There are two types of data types in Java: Primitive data types:  The primitive data types include boolean, char, byte, short, int, long, float and double. Non-primitive data types:  The non-primitive data types include Classes,Interfaces,Arrays. 1) Primitive data types In Java, we have eight primitive data types: boolean, char, byte, short, int, long, float and double. Java developers included these data types to maintain the portability of java as the size of these primitive data types do not change from one operating system to another. byte ,  short ,  int  and  long  data types are used for storing whole numbers. float  and  double  are used for fractional numbers. char  is used for storing characters(letters). boolean  data type is used for variables that holds either true or false. byte: This can hold whole numb...
Read more