Abstracte klasse en interface worden beide gebruikt om contracten in objectgeoriënteerd programmeren te definiëren, maar er zijn enkele belangrijke verschillen tussen beide.

Verschil tussen abstracte klasse en interface: -

Definitie: Een abstracte klasse is een klasse die niet kan worden geïnstantieerd en die zowel abstracte als niet-abstracte methoden kan bevatten. Een interface daarentegen is een contract dat een reeks methoden specificeert die een klasse moet implementeren.

Methode-implementatie: In een abstracte klasse kunnen sommige methoden worden geïmplementeerd, terwijl andere abstract blijven, wat betekent dat ze geen implementatie hebben en moeten worden overschreven door concrete subklassen. Alle methoden in een interface zijn daarentegen standaard abstract en moeten worden geïmplementeerd door elke klasse die de interface implementeert.

Overerving: Een klasse kan slechts van één abstracte klasse erven, maar kan meerdere interfaces implementeren. Dit komt omdat een abstracte klasse een type object vertegenwoordigt, terwijl een interface een reeks gedragingen vertegenwoordigt.

Toegangsmodificatoren: abstracte klassen kunnen toegangsmodificatoren hebben zoals openbaar, beschermd en privé voor hun methoden en eigenschappen, terwijl interfaces alleen openbare toegang kunnen hebben.

Variabelen: Een abstracte klasse kan lidvariabelen hebben, terwijl een interface dat niet kan.

Samenvattend worden abstracte klassen gebruikt om een ​​basisklasse te bieden waarvan concrete subklassen kunnen erven, terwijl interfaces worden gebruikt om een ​​reeks methoden te definiëren die een klasse moet implementeren. Abstracte klassen kunnen geïmplementeerde en abstracte methoden hebben, terwijl interfaces alleen abstracte methoden kunnen hebben. Klassen kunnen slechts van één abstracte klasse erven, maar kunnen meerdere interfaces implementeren.

Zoals we weten verwijst abstractie naar het verbergen van de interne implementatie van de functie en het alleen tonen van de functionaliteit aan de gebruikers. d.w.z. alleen de vereiste functies tonen en verbergen hoe deze functies achter de schermen worden geïmplementeerd. Terwijl een interface een andere manier is om abstractie in Java te bereiken. Beide abstracte klasse En koppel worden gebruikt voor abstractie, voortaan zijn Interface en Abstract Class vereiste vereisten.

Abstracte klasse versus interface

• Soort methoden: Interface kan alleen abstracte methoden hebben. Terwijl een abstracte klasse een abstracte methode en concrete methoden kan hebben. Vanaf Java 8 kan het ook standaard- en statische methoden hebben. Vanaf Java 9 kan het ook privé-betonmethoden hebben.

• Opmerking: Concrete methoden zijn methoden die hun volledige definitie hebben, maar die ook kunnen worden overschreven in de overgeërfde klasse. Als we echter de concrete methode maken als LAATSTE het kan niet worden overschreven in de overgeërfde klasse, omdat het declareren van een methode als uiteindelijk middel – de implementatie ervan is voltooid .

• Laatste variabelen: Variabelen die in een Java-interface worden gedeclareerd, zijn standaard definitief. Een abstracte klasse kan niet-finale variabelen bevatten.
• Type variabelen: Een abstracte klasse kan finale, niet-finale, statische en niet-statische variabelen hebben. De interface heeft alleen statische en definitieve variabelen.
• Implementatie: Een abstracte klasse kan de implementatie van de interface verzorgen. Interface kan niet de implementatie van een abstracte klasse bieden.
• Overerving versus abstractie: Met het trefwoord kan een Java-interface worden geïmplementeerd werktuigen en een abstracte klasse kan worden uitgebreid met behulp van het trefwoord strekt zich uit .
• Meerdere implementaties: Een interface kan een of meer Java-interfaces uitbreiden; een abstracte klasse kan een andere Java-klasse uitbreiden en meerdere Java-interfaces implementeren.
• Meervoudige erfenis: Meervoudige overerving kan gedeeltelijk worden bereikt door het gebruik van interfaces, terwijl hetzelfde niet kan worden gedaan door het gebruik van abstracte klassen. Omdat in Java één klasse meerdere interfaces kan implementeren, maar één klasse zich niet kan uitbreiden van meerdere andere klassen, omdat dat gewoon niet mogelijk is in Java, omdat dat tot het diamantprobleem zou leiden.
• Toegankelijkheid van gegevensleden: Leden (variabelen) van een Java-interface zijn standaard definitief. Een abstracte Java-klasse kan klasseleden hebben zoals private, protected, etc.

Kenmerken van abstracte klasse: -

Een abstracte klasse is een speciaal type klasse in objectgeoriënteerd programmeren dat niet rechtstreeks kan worden geïnstantieerd. In plaats daarvan dient het als blauwdruk of sjabloon waaruit andere klassen kunnen worden afgeleid. Een abstracte klasse:

1. Kan niet worden geïnstantieerd : Abstracte klassen kunnen niet rechtstreeks worden geïnstantieerd, wat betekent dat u geen objecten van een abstracte klasse kunt maken.
2. Bevat minimaal één puur virtuele functie : Abstracte klassen moeten ten minste één puur virtuele functie bevatten, wat betekent dat de functie geen implementatie heeft en moet worden geïmplementeerd door afgeleide klassen.
3. Kan zowel abstracte als niet-abstracte methoden bevatten : Abstracte klassen kunnen zowel abstracte als niet-abstracte methoden hebben. Niet-abstracte methoden hebben een volledige implementatie en kunnen direct worden aangeroepen.
4. Kan constructors en destructors hebben : Abstracte klassen kunnen constructors en destructors hebben, net als elke andere klasse.
5. Kan lidvariabelen bevatten : abstracte klassen kunnen lidvariabelen hebben, dit zijn variabelen die tot een object van de klasse behoren.
6. Kan als basisklasse worden gebruikt : Abstracte klassen kunnen worden gebruikt als basisklasse voor andere klassen, wat betekent dat ze door andere klassen kunnen worden geërfd.

Over het algemeen worden abstracte klassen gebruikt om een ​​gemeenschappelijke interface of gedrag te definiëren dat kan worden gedeeld door meerdere gerelateerde klassen, maar met specifieke implementaties in elke afgeleide klasse.

Voorbeeld 1: (voor abstracte klasse)

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>

Voorbeeld 2: (voor abstracte klasse)

// 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>

Wat als we geen gemeenschappelijke code hebben tussen rechthoek en cirkel, ga dan voor de interface.

Koppel:

Kenmerken van interface:

Een interface:

1. Definieert een reeks methoden en eigenschappen: Een interface definieert een reeks methoden en eigenschappen die moeten worden geïmplementeerd door elke klasse of structuur die de interface implementeert.
2. Biedt een gemeenschappelijk protocol: Interfaces bieden een gemeenschappelijk protocol waarmee verschillende softwarecomponenten met elkaar kunnen communiceren.
3. Ondersteunt polymorfisme: Een interface kan worden gebruikt om polymorfisme te bereiken, wat betekent dat objecten van verschillende klassen kunnen worden behandeld alsof ze tot hetzelfde type behoren, zolang ze maar dezelfde interface implementeren.
4. Maakt scheiding van zorgen mogelijk: Interfaces maken scheiding van belangen mogelijk, wat betekent dat verschillende delen van een softwaresysteem onafhankelijk van elkaar kunnen worden ontwikkeld, zolang ze maar voldoen aan de interfacespecificaties.
5. Verbetert de herbruikbaarheid van code: Interfaces verbeteren de herbruikbaarheid van code doordat verschillende softwarecomponenten dezelfde codebasis kunnen hergebruiken, zolang ze maar dezelfde interface implementeren.
6. Dwingt ontwerppatronen af: Interfaces kunnen worden gebruikt om ontwerppatronen af ​​te dwingen, zoals het adapterpatroon, door te vereisen dat bepaalde methoden of eigenschappen door de implementerende klassen worden geïmplementeerd.
7. Vergemakkelijkt testen: Interfaces vergemakkelijken het testen doordat softwarecomponenten onafhankelijk van elkaar kunnen worden getest, met behulp van nepobjecten die de interface implementeren.

Voorbeeld 1: voor interface

// 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>

Voorbeeld 2: voor interface

// 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>

Wanneer wat gebruiken?

Overweeg het gebruik van abstracte klassen als een van deze uitspraken op uw situatie van toepassing is:

• In de Java-toepassing zijn er enkele verwante klassen die enkele coderegels moeten delen. Vervolgens kunt u deze coderegels in de abstracte klasse plaatsen en deze abstracte klasse moet worden uitgebreid met al deze verwante klassen.
• U kunt de niet-statische of niet-definitieve velden in de abstracte klasse definiëren, zodat u via een methode toegang kunt krijgen tot de status van het object waartoe ze behoren en deze kunt wijzigen.
• Je kunt verwachten dat de klassen die een abstracte klasse uitbreiden veel gemeenschappelijke methoden of velden hebben, of andere toegangsmodifiers vereisen dan public (zoals protected en private).

Overweeg het gebruik van interfaces als een van deze uitspraken op uw situatie van toepassing is:

• Het is een totale abstractie; alle methoden die binnen een interface worden gedeclareerd, moeten worden geïmplementeerd door de klasse(n) die deze interface implementeert.
• Een klasse kan meer dan één interface implementeren. Dit heet meervoudige erfenissen.
• U wilt het gedrag van een bepaald gegevenstype specificeren, maar u maakt zich geen zorgen over wie het gedrag ervan implementeert.