Java - Abstraktion

Laut Wörterbuch, Abstraktion ist die Qualität des Umgangs mit Ideen und nicht mit Ereignissen. Wenn Sie beispielsweise den Fall von E-Mail betrachten, werden komplexe Details, wie zum Beispiel was passiert, sobald Sie eine E-Mail senden, das Protokoll, das Ihr E-Mail-Server verwendet, vor dem Benutzer verborgen. Um eine E-Mail zu senden, müssen Sie daher nur den Inhalt eingeben, die Adresse des Empfängers angeben und auf „Senden“ klicken.

Ebenso ist die Abstraktion in der objektorientierten Programmierung ein Prozess, bei dem die Implementierungsdetails vor dem Benutzer verborgen werden, nur die Funktionalität wird dem Benutzer zur Verfügung gestellt. Mit anderen Worten, der Benutzer hat die Informationen darüber, was das Objekt tut, anstatt wie es es tut.

In Java wird die Abstraktion durch abstrakte Klassen und Schnittstellen erreicht.

Abstrakte Klasse

Eine Klasse, die den Abstract enthält Das Schlüsselwort in seiner Deklaration wird als abstrakte Klasse bezeichnet.

Abstrakte Klassen können abstrakte Methoden enthalten oder nicht , d. h. Methoden ohne Körper ( public void get(); )
Aber wenn eine Klasse mindestens eine abstrakte Methode hat, dann muss die Klasse abstrakt deklariert werden.
Wenn eine Klasse als abstrakt deklariert ist, kann sie nicht instanziiert werden.
Um eine abstrakte Klasse zu verwenden, müssen Sie sie von einer anderen Klasse erben und Implementierungen für die darin enthaltenen abstrakten Methoden bereitstellen.
Wenn Sie eine abstrakte Klasse erben, müssen Sie Implementierungen für alle darin enthaltenen abstrakten Methoden bereitstellen.

Beispiel

Dieser Abschnitt enthält ein Beispiel für die abstrakte Klasse. Um eine abstrakte Klasse zu erstellen, verwenden Sie einfach die Abstract Schlüsselwort vor dem Klassenschlüsselwort in der Klassendeklaration.

/* File name : Employee.java */
public abstract class Employee {
   private String name;
   private String address;
   private int number;

   public Employee(String name, String address, int number) {
      System.out.println("Constructing an Employee");
      this.name = name;
      this.address = address;
      this.number = number;
   }
   
   public double computePay() {
     System.out.println("Inside Employee computePay");
     return 0.0;
   }
   
   public void mailCheck() {
      System.out.println("Mailing a check to " + this.name + " " + this.address);
   }

   public String toString() {
      return name + " " + address + " " + number;
   }

   public String getName() {
      return name;
   }
 
   public String getAddress() {
      return address;
   }
   
   public void setAddress(String newAddress) {
      address = newAddress;
   }
 
   public int getNumber() {
      return number;
   }
}

Sie können beobachten, dass die Employee-Klasse mit Ausnahme der abstrakten Methoden dieselbe ist wie die normale Klasse in Java. Die Klasse ist jetzt abstrakt, hat aber immer noch drei Felder, sieben Methoden und einen Konstruktor.

Jetzt können Sie versuchen, die Employee-Klasse auf folgende Weise zu instanziieren −

/* File name : AbstractDemo.java */
public class AbstractDemo {

   public static void main(String [] args) {
      /* Following is not allowed and would raise error */
      Employee e = new Employee("George W.", "Houston, TX", 43);
      System.out.println("\n Call mailCheck using Employee reference--");
      e.mailCheck();
   }
}

Wenn Sie die obige Klasse kompilieren, erhalten Sie den folgenden Fehler −

Employee.java:46: Employee is abstract; cannot be instantiated
      Employee e = new Employee("George W.", "Houston, TX", 43);
                   ^
1 error

Erben der abstrakten Klasse

Wir können die Eigenschaften der Employee-Klasse genau wie die konkrete Klasse auf folgende Weise erben −

Beispiel

/* File name : Salary.java */
public class Salary extends Employee {
   private double salary;   // Annual salary
   
   public Salary(String name, String address, int number, double salary) {
      super(name, address, number);
      setSalary(salary);
   }
   
   public void mailCheck() {
      System.out.println("Within mailCheck of Salary class ");
      System.out.println("Mailing check to " + getName() + " with salary " + salary);
   }
 
   public double getSalary() {
      return salary;
   }
   
   public void setSalary(double newSalary) {
      if(newSalary >= 0.0) {
         salary = newSalary;
      }
   }
   
   public double computePay() {
      System.out.println("Computing salary pay for " + getName());
      return salary/52;
   }
}

Hier können Sie die Employee-Klasse nicht instanziieren, aber Sie können die Gehaltsklasse instanziieren, und mit dieser Instanz können Sie auf alle drei Felder und sieben Methoden der Employee-Klasse zugreifen, wie unten gezeigt.

/* File name : AbstractDemo.java */
public class AbstractDemo {

   public static void main(String [] args) {
      Salary s = new Salary("Mohd Mohtashim", "Ambehta, UP", 3, 3600.00);
      Employee e = new Salary("John Adams", "Boston, MA", 2, 2400.00);
      System.out.println("Call mailCheck using Salary reference --");
      s.mailCheck();
      System.out.println("\n Call mailCheck using Employee reference--");
      e.mailCheck();
   }
}

Dies erzeugt das folgende Ergebnis −

Ausgabe

Constructing an Employee
Constructing an Employee
Call mailCheck using Salary reference --
Within mailCheck of Salary class 
Mailing check to Mohd Mohtashim with salary 3600.0

 Call mailCheck using Employee reference--
Within mailCheck of Salary class 
Mailing check to John Adams with salary 2400.0

Abstrakte Methoden

Wenn Sie möchten, dass eine Klasse eine bestimmte Methode enthält, aber Sie möchten, dass die tatsächliche Implementierung dieser Methode von untergeordneten Klassen bestimmt wird, können Sie die Methode in der übergeordneten Klasse als Abstract deklarieren.

abstrakt wird verwendet, um die Methode als abstrakt zu deklarieren.
Sie müssen den Abstract platzieren Schlüsselwort vor dem Methodennamen in der Methodendeklaration.
Eine abstrakte Methode enthält eine Methodensignatur, aber keinen Methodenrumpf.
Anstelle von geschweiften Klammern hat eine abstrakte Methode einen Semikolon (;) am Ende.

Es folgt ein Beispiel für die abstrakte Methode.

Beispiel

public abstract class Employee {
   private String name;
   private String address;
   private int number;
   
   public abstract double computePay();
   // Remainder of class definition
}

Eine Methode als abstrakt zu deklarieren hat zwei Konsequenzen −

Die Klasse, die es enthält, muss als abstrakt deklariert werden.
Jede Klasse, die die aktuelle Klasse erbt, muss entweder die abstrakte Methode überschreiben oder sich selbst als abstrakt deklarieren.

Hinweis − Eventuell muss eine Nachkommenklasse die abstrakte Methode implementieren; Andernfalls hätten Sie eine Hierarchie abstrakter Klassen, die nicht instanziiert werden können.

Angenommen, die Gehaltsklasse erbt die Employee-Klasse, dann sollte sie computePay() implementieren Methode wie unten gezeigt −

/* File name : Salary.java */
public class Salary extends Employee {
   private double salary;   // Annual salary
  
   public double computePay() {
      System.out.println("Computing salary pay for " + getName());
      return salary/52;
   }
   // Remainder of class definition
}

Java - Polymorphismus Java - Kapselung

Java