Abstrakte Klassen und Schnittstellen werden beide zum Definieren von Verträgen in der objektorientierten Programmierung verwendet, es gibt jedoch einige wesentliche Unterschiede zwischen ihnen.

Unterschied zwischen abstrakter Klasse und Schnittstelle:-

Definition: Eine abstrakte Klasse ist eine Klasse, die nicht instanziiert werden kann und sowohl abstrakte als auch nicht abstrakte Methoden enthalten kann. Eine Schnittstelle hingegen ist ein Vertrag, der eine Reihe von Methoden angibt, die eine Klasse implementieren muss.

Methodenimplementierung: In einer abstrakten Klasse können einige Methoden implementiert werden, während andere abstrakt bleiben, was bedeutet, dass sie keine Implementierung haben und von konkreten Unterklassen überschrieben werden müssen. Im Gegensatz dazu sind alle Methoden in einer Schnittstelle standardmäßig abstrakt und müssen von jeder Klasse implementiert werden, die die Schnittstelle implementiert.

Was ist Androids Easter Egg?

Vererbung: Eine Klasse kann nur von einer abstrakten Klasse erben, aber mehrere Schnittstellen implementieren. Dies liegt daran, dass eine abstrakte Klasse einen Objekttyp darstellt, während eine Schnittstelle eine Reihe von Verhaltensweisen darstellt.

Zugriffsmodifikatoren: Abstrakte Klassen können Zugriffsmodifikatoren wie „public“, „protected“ und „private“ für ihre Methoden und Eigenschaften haben, während Schnittstellen nur öffentlichen Zugriff haben können.

Variablen: Eine abstrakte Klasse kann Mitgliedsvariablen haben, eine Schnittstelle jedoch nicht.

Zusammenfassend lässt sich sagen, dass abstrakte Klassen verwendet werden, um eine Basisklasse für konkrete Unterklassen bereitzustellen, von denen sie erben können, während Schnittstellen verwendet werden, um eine Reihe von Methoden zu definieren, die eine Klasse implementieren muss. Abstrakte Klassen können implementierte und abstrakte Methoden haben, während Schnittstellen nur abstrakte Methoden haben können. Klassen können nur von einer abstrakten Klasse erben, aber mehrere Schnittstellen implementieren.

Wie wir wissen, bezieht sich Abstraktion darauf, die interne Implementierung der Funktion zu verbergen und den Benutzern nur die Funktionalität anzuzeigen. d. h. es werden nur die erforderlichen Funktionen angezeigt und ausgeblendet, wie diese Funktionen hinter den Kulissen implementiert werden. Eine Schnittstelle hingegen ist eine weitere Möglichkeit, in Java eine Abstraktion zu erreichen. Beide abstrakte Klasse Und Schnittstelle werden zur Abstraktion verwendet, daher sind Interface und Abstract Class erforderliche Voraussetzungen.

Abstrakte Klasse vs. Schnittstelle

• Art der Methoden: Die Schnittstelle kann nur abstrakte Methoden haben. Eine abstrakte Klasse hingegen kann eine abstrakte Methode und konkrete Methoden haben. Ab Java 8 kann es auch Standard- und statische Methoden haben. Ab Java 9 kann es auch private konkrete Methoden geben.

• Hinweis: Konkrete Methoden sind solche Methoden, die ihre vollständige Definition haben, aber auch in der geerbten Klasse überschrieben werden können. Wenn wir jedoch die konkrete Methode als machen FINALE Es kann in der geerbten Klasse nicht überschrieben werden, da die Deklaration einer Methode als endgültige Mittel – die Umsetzung ist abgeschlossen .

• Endgültige Variablen: In einer Java-Schnittstelle deklarierte Variablen sind standardmäßig endgültig. Eine abstrakte Klasse kann nicht-finale Variablen enthalten.
• Art der Variablen: Abstrakte Klassen können finale, nicht finale, statische und nicht statische Variablen haben. Die Schnittstelle verfügt nur über statische und endgültige Variablen.
• Implementierung: Eine abstrakte Klasse kann die Implementierung der Schnittstelle bereitstellen. Die Schnittstelle kann die Implementierung einer abstrakten Klasse nicht bereitstellen.
• Vererbung vs. Abstraktion: Mit dem Schlüsselwort kann eine Java-Schnittstelle implementiert werden implementiert und eine abstrakte Klasse kann mit dem Schlüsselwort erweitert werden erweitert .
• Mehrere Implementierungen: Eine Schnittstelle kann eine oder mehrere Java-Schnittstellen erweitern; Eine abstrakte Klasse kann eine andere Java-Klasse erweitern und mehrere Java-Schnittstellen implementieren.
• Mehrfachvererbung: Mehrfachvererbung kann teilweise durch die Verwendung von Schnittstellen erreicht werden, wohingegen dies nicht durch die Verwendung abstrakter Klassen erreicht werden kann. Denn in Java kann eine Klasse mehrere Schnittstellen implementieren, aber eine Klasse kann nicht von mehreren anderen Klassen erweitert werden, da dies in Java einfach nicht möglich ist, da dies zum Diamantproblem führen würde.
• Zugänglichkeit von Datenmitgliedern: Mitglieder (Variablen) einer Java-Schnittstelle sind standardmäßig endgültig. Eine abstrakte Java-Klasse kann Klassenmitglieder wie private, geschützte usw. haben.

Merkmale der abstrakten Klasse: –

Eine abstrakte Klasse ist ein spezieller Klassentyp in der objektorientierten Programmierung, der nicht direkt instanziiert werden kann. Stattdessen dient es als Blaupause oder Vorlage für die Ableitung anderer Klassen. Eine abstrakte Klasse:

1. Kann nicht instanziiert werden : Abstrakte Klassen können nicht direkt instanziiert werden, was bedeutet, dass Sie keine Objekte einer abstrakten Klasse erstellen können.
2. Enthält mindestens eine rein virtuelle Funktion : Abstrakte Klassen müssen mindestens eine rein virtuelle Funktion enthalten, was bedeutet, dass die Funktion keine Implementierung hat und von allen abgeleiteten Klassen implementiert werden muss.
3. Kann sowohl abstrakte als auch nicht abstrakte Methoden enthalten : Abstrakte Klassen können sowohl abstrakte als auch nicht abstrakte Methoden haben. Nicht abstrakte Methoden verfügen über eine vollständige Implementierung und können direkt aufgerufen werden.
4. Kann Konstruktoren und Destruktoren haben : Abstrakte Klassen können wie jede andere Klasse Konstruktoren und Destruktoren haben.
5. Kann Mitgliedsvariablen haben : Abstrakte Klassen können Mitgliedsvariablen haben, bei denen es sich um Variablen handelt, die zu einem Objekt der Klasse gehören.
6. Kann als Basisklasse verwendet werden : Abstrakte Klassen können als Basisklasse für andere Klassen verwendet werden, was bedeutet, dass sie von anderen Klassen geerbt werden können.

Insgesamt werden abstrakte Klassen verwendet, um eine gemeinsame Schnittstelle oder ein gemeinsames Verhalten zu definieren, das von mehreren verwandten Klassen gemeinsam genutzt werden kann, jedoch mit spezifischen Implementierungen in jeder abgeleiteten Klasse.

Normalisierung in der Datenbank

Beispiel 1: (Für abstrakte 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>

Beispiel 2: (Für abstrakte 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>

Was ist, wenn wir keinen gemeinsamen Code zwischen Rechteck und Kreis haben, dann entscheiden wir uns für die Schnittstelle.

Schnittstelle:

Merkmale der Schnittstelle:

Eine Schnittstelle:

1. Definiert eine Reihe von Methoden und Eigenschaften: Eine Schnittstelle definiert eine Reihe von Methoden und Eigenschaften, die von jeder Klasse oder Struktur implementiert werden müssen, die die Schnittstelle implementiert.
2. Stellt ein gemeinsames Protokoll bereit: Schnittstellen stellen ein gemeinsames Protokoll bereit, das es verschiedenen Softwarekomponenten ermöglicht, miteinander zu kommunizieren.
3. Unterstützt Polymorphismus: Eine Schnittstelle kann verwendet werden, um Polymorphismus zu erreichen. Dies bedeutet, dass Objekte verschiedener Klassen so behandelt werden können, als ob sie zum selben Typ gehören würden, solange sie dieselbe Schnittstelle implementieren.
4. Ermöglicht die Trennung von Belangen: Schnittstellen ermöglichen eine Trennung von Belangen, was bedeutet, dass verschiedene Teile eines Softwaresystems unabhängig voneinander entwickelt werden können, sofern sie den Schnittstellenspezifikationen entsprechen.
5. Verbessert die Wiederverwendbarkeit von Code: Schnittstellen verbessern die Wiederverwendbarkeit von Code, indem sie es verschiedenen Softwarekomponenten ermöglichen, dieselbe Codebasis wiederzuverwenden, solange sie dieselbe Schnittstelle implementieren.
6. Erzwingt Entwurfsmuster: Schnittstellen können verwendet werden, um Entwurfsmuster wie das Adaptermuster durchzusetzen, indem sie erfordern, dass bestimmte Methoden oder Eigenschaften von den implementierenden Klassen implementiert werden.
7. Erleichtert das Testen: Schnittstellen erleichtern das Testen, indem sie es ermöglichen, Softwarekomponenten unabhängig voneinander zu testen, indem Scheinobjekte verwendet werden, die die Schnittstelle implementieren.

Beispiel 1: Für Schnittstelle

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

Beispiel 2: Für Schnittstelle

Lambda-Funktion Java

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

Wann was verwenden?

Erwägen Sie die Verwendung abstrakter Klassen, wenn eine dieser Aussagen auf Ihre Situation zutrifft:

• In der Java-Anwendung gibt es einige verwandte Klassen, die einige Codezeilen gemeinsam nutzen müssen. Anschließend können Sie diese Codezeilen in die abstrakte Klasse einfügen, und diese abstrakte Klasse sollte um alle diese verwandten Klassen erweitert werden.
• Sie können die nicht-statischen oder nicht-finalen Felder in der abstrakten Klasse definieren, sodass Sie über eine Methode auf den Status des Objekts, zu dem sie gehören, zugreifen und ihn ändern können.
• Sie können davon ausgehen, dass die Klassen, die eine abstrakte Klasse erweitern, viele gemeinsame Methoden oder Felder haben oder andere als öffentliche Zugriffsmodifikatoren erfordern (z. B. geschützt und privat).

Erwägen Sie die Verwendung von Schnittstellen, wenn eine dieser Aussagen auf Ihre Situation zutrifft:

• Es handelt sich um eine vollständige Abstraktion. Alle innerhalb einer Schnittstelle deklarierten Methoden müssen von der/den Klasse(n) implementiert werden, die diese Schnittstelle implementiert.
• Eine Klasse kann mehr als eine Schnittstelle implementieren. Man spricht von Mehrfacherben.
• Sie möchten das Verhalten eines bestimmten Datentyps festlegen, machen sich aber keine Gedanken darüber, wer sein Verhalten implementiert.