Abstrakt klass och gränssnitt används båda för att definiera kontrakt i objektorienterad programmering, men det finns några viktiga skillnader mellan dem.

Skillnaden mellan abstrakt klass och gränssnitt: -

Definition: En abstrakt klass är en klass som inte kan instansieras och kan innehålla både abstrakta och icke-abstrakta metoder. Ett gränssnitt, å andra sidan, är ett kontrakt som specificerar en uppsättning metoder som en klass måste implementera.

Metodimplementering: I en abstrakt klass kan vissa metoder implementeras, medan andra lämnas abstrakta, vilket innebär att de inte har någon implementering och måste åsidosättas av konkreta underklasser. Däremot är alla metoder i ett gränssnitt som standard abstrakta och måste implementeras av alla klasser som implementerar gränssnittet.

Arv: En klass kan ärva från endast en abstrakt klass, men den kan implementera flera gränssnitt. Detta beror på att en abstrakt klass representerar en typ av objekt, medan ett gränssnitt representerar en uppsättning beteenden.

Åtkomstmodifierare: Abstrakta klasser kan ha åtkomstmodifierare som offentlig, skyddad och privat för sina metoder och egenskaper, medan gränssnitt endast kan ha offentlig åtkomst.

Variabler: En abstrakt klass kan ha medlemsvariabler, medan ett gränssnitt inte kan.

Sammanfattningsvis används abstrakta klasser för att tillhandahålla en basklass för konkreta underklasser att ärva från, medan gränssnitt används för att definiera en uppsättning metoder som en klass måste implementera. Abstrakta klasser kan ha implementerade och abstrakta metoder, medan gränssnitt endast kan ha abstrakta metoder. Klasser kan ärva från endast en abstrakt klass, men kan implementera flera gränssnitt.

Som vi vet avser abstraktion att dölja den interna implementeringen av funktionen och endast visa funktionaliteten för användarna. d.v.s. visar bara de nödvändiga funktionerna och döljer hur dessa funktioner implementeras bakom scenen. Medan ett gränssnitt är ett annat sätt att uppnå abstraktion i java. Både abstrakt klass och gränssnitt används för abstraktion, hädanefter är gränssnitt och abstrakt klass obligatoriska förkunskaper.

Abstrakt klass vs gränssnitt

• Typ av metoder: Gränssnitt kan bara ha abstrakta metoder. Medan en abstrakt klass kan ha abstrakt metod och konkreta metoder. Från Java 8 kan den också ha standardmetoder och statiska metoder. Från Java 9 kan det också ha privata konkreta metoder.

• Obs: Konkreta metoder är de metoder som har sin fullständiga definition men de kan också åsidosättas i den ärvda klassen. Men om vi gör den konkreta metoden som SLUTLIG den kan inte åsidosättas i den ärvda klassen eftersom att deklarera en metod som slutgiltig betyder - dess genomförande är slutfört .

• Slutliga variabler: Variabler som deklareras i ett Java-gränssnitt är som standard slutgiltiga. En abstrakt klass kan innehålla icke-slutliga variabler.
• Typ av variabler: Abstrakt klass kan ha slutliga, icke-slutliga, statiska och icke-statiska variabler. Gränssnittet har endast statiska och slutliga variabler.
• Genomförande: Abstrakt klass kan ge implementeringen av gränssnittet. Gränssnittet kan inte tillhandahålla implementeringen av en abstrakt klass.
• Arv vs abstraktion: Ett Java-gränssnitt kan implementeras med nyckelordet redskap och en abstrakt klass kan utökas med nyckelordet sträcker sig .
• Flera implementeringar: Ett gränssnitt kan utöka ett eller flera Java-gränssnitt; en abstrakt klass kan utöka en annan Java-klass och implementera flera Java-gränssnitt.
• Multipelt arv: Multipelt arv kan delvis uppnås genom användning av gränssnitt, medan detsamma inte kan göras genom att använda abstrakta klasser. För i Java kan en klass implementera flera gränssnitt, men en klass kan inte sträcka sig från flera andra klasser eftersom det helt enkelt inte är möjligt i java eftersom det skulle leda till diamantproblemet.
• Tillgänglighet för datamedlemmar: Medlemmar (variabler) i ett Java-gränssnitt är slutgiltiga som standard. En abstrakt Java-klass kan ha klassmedlemmar som privat, skyddad, etc.

Funktioner i abstrakt klass: -

En abstrakt klass är en speciell typ av klass inom objektorienterad programmering som inte kan instansieras direkt. Istället fungerar den som en ritning eller mall för andra klasser att härledas från. En abstrakt klass:

1. Kan inte instansieras : Abstrakta klasser kan inte instansieras direkt, vilket innebär att du inte kan skapa objekt av en abstrakt klass.
2. Innehåller minst en ren virtuell funktion : Abstrakta klasser måste innehålla minst en ren virtuell funktion, vilket innebär att funktionen inte har någon implementering och måste implementeras av eventuella härledda klasser.
3. Kan innehålla både abstrakta och icke-abstrakta metoder : Abstrakta klasser kan ha både abstrakta och icke-abstrakta metoder. Icke-abstrakta metoder har en fullständig implementering och kan anropas direkt.
4. Kan ha konstruktörer och förstörare : Abstrakta klasser kan ha konstruktörer och destruktorer som alla andra klasser.
5. Kan ha medlemsvariabler : Abstrakta klasser kan ha medlemsvariabler, som är variabler som tillhör ett objekt i klassen.
6. Kan användas som basklass : Abstrakta klasser kan användas som basklass för andra klasser, vilket innebär att de kan ärvas av andra klasser.

Sammantaget används abstrakta klasser för att definiera ett gemensamt gränssnitt eller beteende som kan delas av flera relaterade klasser, men med specifika implementeringar i varje härledd klass.

Exempel 1 : (För abstrakt klass )

abstract class sunstar {    abstract void printInfo(); } class employee extends sunstar {  void printInfo()  {  String name = 'avinash';  int age = 21;  float salary = 222.2F;  System.out.println(name);  System.out.println(age);  System.out.println(salary);  } } class base {  public static void main(String args[])  {  sunstar s = new employee();  s.printInfo();  } }>

avinash 21 222.2>

Exempel 2: (för abstrakt klass)

// Java Program to Illustrate Concept of // Abstract Class // Importing required classes import java.io.*; // Class 1 // Helper abstract class abstract class Shape {  // Declare fields  String objectName = ' ';  // Constructor of this class  Shape(String name) { this.objectName = name; }  // Method  // Non-abstract methods  // Having as default implementation  public void moveTo(int x, int y)  {  System.out.println(this.objectName + ' '  + 'has been moved to'  + ' x = ' + x + ' and y = ' + y);  }  // Method 2  // Abstract methods which will be  // implemented by its subclass(es)  abstract public double area();  abstract public void draw(); } // Class 2 // Helper class extending Class 1 class Rectangle extends Shape {  // Attributes of rectangle  int length, width;  // Constructor  Rectangle(int length, int width, String name)  {  // Super keyword refers to current instance itself  super(name);  // this keyword refers to current instance itself  this.length = length;  this.width = width;  }  // Method 1  // To draw rectangle  @Override public void draw()  {  System.out.println('Rectangle has been drawn ');  }  // Method 2  // To compute rectangle area  @Override public double area()  {  // Length * Breadth  return (double)(length * width);  } } // Class 3 // Helper class extending Class 1 class Circle extends Shape {  // Attributes of a Circle  double pi = 3.14;  int radius;  // Constructor  Circle(int radius, String name)  {  // Super keyword refers to parent class  super(name);  // This keyword refers to current instance itself  this.radius = radius;  }  // Method 1  // To draw circle  @Override public void draw()  {  // Print statement  System.out.println('Circle has been drawn ');  }  // Method 2  // To compute circle area  @Override public double area()  {  return (double)((pi * radius * radius));  } } // Class 4 // Main class class GFG {  // Main driver method  public static void main(String[] args)  {  // Creating the Object of Rectangle class  // and using shape class reference.  Shape rect = new Rectangle(2, 3, 'Rectangle');  System.out.println('Area of rectangle: '  + rect.area());  rect.moveTo(1, 2);  System.out.println(' ');  // Creating the Objects of circle class  Shape circle = new Circle(2, 'Circle');  System.out.println('Area of circle: '  + circle.area());  circle.moveTo(2, 4);  } }>

Area of rectangle: 6.0 Rectangle has been moved to x = 1 and y = 2 Area of circle: 12.56 Circle has been moved to x = 2 and y = 4>

Tänk om vi inte har någon gemensam kod mellan rektangel och cirkel, gå sedan med gränssnittet.

Gränssnitt:

Funktioner i gränssnittet:

Ett gränssnitt:

1. Definierar en uppsättning metoder och egenskaper: Ett gränssnitt definierar en uppsättning metoder och egenskaper som måste implementeras av någon klass eller struktur som implementerar gränssnittet.
2. Ger ett gemensamt protokoll: Gränssnitt ger ett gemensamt protokoll som gör att olika programvarukomponenter kan kommunicera med varandra.
3. Stöder polymorfism: Ett gränssnitt kan användas för att uppnå polymorfism, vilket innebär att objekt av olika klasser kan behandlas som om de tillhör samma typ, så länge de implementerar samma gränssnitt.
4. Möjliggör separation av bekymmer: Gränssnitt möjliggör separation av problem, vilket innebär att olika delar av ett mjukvarusystem kan utvecklas oberoende av varandra, så länge de följer gränssnittsspecifikationerna.
5. Förbättrar kodåteranvändbarhet: Gränssnitt förbättrar kodåteranvändbarhet genom att tillåta olika programvarukomponenter att återanvända samma kodbas, så länge de implementerar samma gränssnitt.
6. Framhäver designmönster: Gränssnitt kan användas för att framtvinga designmönster, såsom adaptermönstret, genom att kräva att vissa metoder eller egenskaper implementeras av de implementerande klasserna.
7. Underlättar testning: Gränssnitt underlättar testning genom att tillåta programvarukomponenter att testas oberoende av varandra, med hjälp av skenobjekt som implementerar gränssnittet.

Exempel 1: För gränssnitt

// Java Program to Illustrate Concept of Interface // Importing I/O classes import java.io.*; // Interface interface Shape {  // Abstract method  void draw();  double area(); } // Class 1 // Helper class class Rectangle implements Shape {  int length, width;  // constructor  Rectangle(int length, int width)  {  this.length = length;  this.width = width;  }  @Override public void draw()  {  System.out.println('Rectangle has been drawn ');  }  @Override public double area()  {  return (double)(length * width);  } } // Class 2 // Helper class class Circle implements Shape {  double pi = 3.14;  int radius;  // constructor  Circle(int radius) { this.radius = radius; }  @Override public void draw()  {  System.out.println('Circle has been drawn ');  }  @Override public double area()  {  return (double)((pi * radius * radius));  } } // Class 3 // Main class class GFG {  // Main driver method  public static void main(String[] args)  {  // Creating the Object of Rectangle class  // and using shape interface reference.  Shape rect = new Rectangle(2, 3);  System.out.println('Area of rectangle: '  + rect.area());  // Creating the Objects of circle class  Shape circle = new Circle(2);  System.out.println('Area of circle: '  + circle.area());  } }>

Area of rectangle: 6.0 Area of circle: 12.56>

Exempel 2: För gränssnitt

// Java Program to Illustrate Concept of Interface // Importing I/O classes import java.io.*; // Interface interface Shape {  // Abstract method  void draw();  double area(); } // Class 1 // Helper class class Rectangle implements Shape {  int length, width;  // constructor  Rectangle(int length, int width)  {  this.length = length;  this.width = width;  }  @Override public void draw()  {  System.out.println('Rectangle has been drawn ');  }  @Override public double area()  {  return (double)(length * width);  } } // Class 2 // Helper class class Circle implements Shape {  double pi = 3.14;  int radius;  // constructor  Circle(int radius) { this.radius = radius; }  @Override public void draw()  {  System.out.println('Circle has been drawn ');  }  @Override public double area()  {  return (double)((pi * radius * radius));  } } // Class 3 // Main class class GFG {  // Main driver method  public static void main(String[] args)  {  // Creating the Object of Rectangle class  // and using shape interface reference.  Shape rect = new Rectangle(2, 3);  System.out.println('Area of rectangle: '  + rect.area());  // Creating the Objects of circle class  Shape circle = new Circle(2);  System.out.println('Area of circle: '  + circle.area());  } }>

Area of rectangle: 6.0 Area of circle: 12.56>

När ska man använda vad?

Överväg att använda abstrakta klasser om något av dessa påståenden gäller din situation:

• I Java-applikationen finns det några relaterade klasser som behöver dela några rader kod, sedan kan du lägga dessa kodrader i abstraktklassen och den här abstrakta klassen bör utökas med alla dessa relaterade klasser.
• Du kan definiera de icke-statiska eller icke-slutliga fälten i abstraktklassen så att du via en metod kan komma åt och ändra tillståndet för objektet som de tillhör.
• Du kan förvänta dig att klasserna som utökar en abstrakt klass har många vanliga metoder eller fält, eller kräver andra åtkomstmodifierare än offentliga (som skyddade och privata).

Överväg att använda gränssnitt om något av dessa påståenden gäller din situation:

• Det är en total abstraktion, alla metoder som deklareras inom ett gränssnitt måste implementeras av klassen/klasserna som implementerar detta gränssnitt.
• En klass kan implementera mer än ett gränssnitt. Det kallas multipla arv.
• Du vill specificera beteendet för en viss datatyp men bryr dig inte om vem som implementerar dess beteende.