Java - Abstractie

Volgens woordenboek, abstractie is de kwaliteit van het omgaan met ideeën in plaats van gebeurtenissen. Als u bijvoorbeeld kijkt naar e-mail, worden complexe details zoals wat er gebeurt zodra u een e-mail verzendt, het protocol dat uw e-mailserver gebruikt, voor de gebruiker verborgen. Om een e-mail te verzenden hoeft u dus alleen maar de inhoud in te typen, het adres van de ontvanger te vermelden en op verzenden te klikken.

Evenzo is abstractie bij objectgeoriënteerd programmeren een proces waarbij de implementatiedetails voor de gebruiker worden verborgen, alleen de functionaliteit wordt aan de gebruiker verstrekt. Met andere woorden, de gebruiker heeft de informatie over wat het object doet in plaats van hoe het het doet.

In Java wordt abstractie bereikt met behulp van abstracte klassen en interfaces.

Abstracte les

Een klasse die de abstracte . bevat trefwoord in zijn declaratie staat bekend als abstracte klasse.

Abstracte klassen kunnen al dan niet abstracte methoden bevatten , d.w.z. methoden zonder body ( public void get(); )
Maar als een klasse ten minste één abstracte methode heeft, dan moet de klasse moet abstract worden verklaard.
Als een klasse abstract is verklaard, kan deze niet worden geïnstantieerd.
Om een abstracte klasse te gebruiken, moet je deze erven van een andere klasse, implementaties geven aan de abstracte methoden erin.
Als je een abstracte klasse erft, moet je implementaties geven aan alle abstracte methoden erin.

Voorbeeld

Deze sectie geeft u een voorbeeld van de abstracte klasse. Gebruik de abstracte . om een abstracte klasse te maken trefwoord vóór het trefwoord klasse, in de declaratie van de klasse.

/* 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;
   }
}

U kunt zien dat, behalve abstracte methoden, de klasse Employee hetzelfde is als de normale klasse in Java. De klasse is nu abstract, maar heeft nog steeds drie velden, zeven methoden en één constructor.

Nu kunt u op de volgende manier proberen de klasse Werknemer te instantiëren −

/* 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();
   }
}

Wanneer je de bovenstaande klasse compileert, krijg je de volgende foutmelding −

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

De abstracte klasse erven

We kunnen de eigenschappen van de klasse Employee net als de concrete klasse op de volgende manier erven −

Voorbeeld

/* 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 kunt u de klasse Werknemer niet instantiëren, maar wel de Salarisklasse, en met deze instantie hebt u toegang tot alle drie velden en zeven methoden van de klasse Werknemer, zoals hieronder weergegeven.

/* 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();
   }
}

Dit levert het volgende resultaat op −

Uitvoer

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

Abstracte methoden

Als je wilt dat een klasse een bepaalde methode bevat, maar je wilt dat de daadwerkelijke implementatie van die methode wordt bepaald door onderliggende klassen, dan kun je de methode in de bovenliggende klasse declareren als een samenvatting.

samenvatting trefwoord wordt gebruikt om de methode als abstract te declareren.
U moet de abstracte . plaatsen trefwoord voor de naam van de methode in de declaratie van de methode.
Een abstracte methode bevat een methodehandtekening, maar geen hoofdtekst van een methode.
In plaats van accolades heeft een abstracte methode een semoi dubbele punt (;) aan het einde.

Hieronder volgt een voorbeeld van de abstracte methode.

Voorbeeld

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

Een methode als abstract declareren heeft twee consequenties −

De klasse die het bevat, moet als abstract worden gedeclareerd.
Elke klasse die de huidige klasse erft, moet ofwel de abstracte methode overschrijven of zichzelf als abstract declareren.

Opmerking − Uiteindelijk moet een descendant-klasse de abstracte methode implementeren; anders zou je een hiërarchie van abstracte klassen hebben die niet kan worden geïnstantieerd.

Stel dat de salarisklasse de klasse Werknemer erft, dan moet deze de computePay() implementeren methode zoals hieronder getoond −

/* 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 - Polymorfisme Java - Inkapseling

Java