آموزش انتزاعی سازی (Abstraction) در جاوا

همانطور که در دیکشنری آمده است، Abstraction تعریفی است، که به جای رخدادها با ایده ها سر و کار دارد. به عنوان مثال در مورد ایمیل، پروتکلی که سرور ایمیل شما استفاده میکند از کاربر پنهان است، از این رو برای ارسال یک ایمیل کاربر تنها نیاز به تایپ content، آدرس گیرنده و کلیک برو روی send خواهد داشت. بدین معنی که کاربر ایمیل خود را ارسال می کند ولی دقیقا نمی داند ارسال ایمیل چگونه انجام میگیرد.

در جاوا (Java) نیز انتزاعی سازی (Abstraction)، پروسه ی پنهان سازی نحوه پیاده سازی جزئیات از کاربر است، تنها عملکرد کلی به کاربر ارائه خواهد شد. به عبارت دیگر، کاربر به جای داشتن اطلاعات درباره چگونگی انجام کار توسط شیء، به اطلاعاتی درباره آنچه که شیء انجام میدهد خواهد داشت.

در جاوا Abstraction با استفاده از کلاس های abstract و اینترفیس ها انجام پذیر است.

کلاس Abstract

کلاسی که در تعریف آن از کلمه کلیدی abstract استفاده شده باشد، به عنوان کلاس abstract شناخته میشود.

کلاس های abstract می توانند دارای توابع abstract (توابع بدون بدنه مانند public void get();) باشند یا نباشند.
ولی اگر یک کلاس دارای حداقل یک تابع abstract باشد، در اینصورت آن کلاس باید حتما به صورت abstract تعریف شود.
اگر یک کلاس به صورت abstract تعریف شود، آن کلاس دیگر نمیتواند instantiate شود.
برای استفاده از یک کلاس abstract، شما باید آن کلاس را توسط کلاسی دیگر ارث بری کنید، و توابع abstract آن را پیاده سازی کنید.
کلاسی که از یک کلاس abstract ارث بری میکند، باید تمامی توابع abstract آن کلاس را پیاده سازی کند.

مثال

در زیر مثالی از کلاس abstract ارائه شده است، برای ساختن یک کلاس abstract تنها کافی است در تعریف کلاس، کلمه کلیدی abstract را قبل از کلمه کلیدی class استفاده کنید.

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

می توان مشاهده کرد که، کلاس فوق به جز توابع abstract ای که در آن تعریف شده است، درست مثل یک کلاس عادی جاوا است. کلاس Employee حالا یک abstract می باشد، ولی همچنان دارای سه فیلد، هفت تابع، و یک سازنده (constructor) است.

حالا می توانید سعی کنید کلاس Employee را همانند زیر instantiate کنید:

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

زمانی که شما کد بالا را کامپایل کنید، خطای زیر رخ خواهد داد:

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

ارث بری کردن از کلاس Abstract

همانطور که در کد زیر مشاهده می کنید، می توان خصوصیات کلاس Employee را درست مانند یک کلاس معمولی ارث بری کرد:

/* File name : Salary.java */
public class Salary extends Employee {
   private double 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;
   }
}

در اینجا، شما نمی توانید کلاس Employee را instantiate کنید، ولی می توانید کلاس Salary را instantiate کنید، و با استفاده از این instance، همانطور که در کد زیر مشاهده میکنید، می توانید به تمامی سه فیلد و هفت تابع کلاس Employee دسترسی پیدا کنید.

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

خروجی برنامه:

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

Call mailCheck using Employee reference--
Within mailCheck of Salary class
ailing check to John Adams with salary 2400.

توابع Abstract

در صورتی که می خواهید یک کلاس دارای یک تابع بخصوص باشد، ولی پیاده سازی آن تابع تنها توسط کلاس های فرزند (کلاس هایی که از این کلاس ارث بری کرده اند) باشد، آنگاه شما میتوانید تابع را در کلاس پدر به صورت abstract تعریف کنید.

کلمه کلیدی abstract برای تعریف تابع به صورت abstract استفاده میشود.
کلمه کلیدی abstract در تعریف تابع باید قبل از نام آن استفاده شود.
یک تابع abstract تنها حاوی تعریف تابع است، و هیچ بدنه ای ندارد، بدین معنی که تابع abstract در زمان تعریف پیاده سازی نمی شود.
تابع abstract به جای آکولاد یک سمی کالن (;) در انتهای تعریف خود دارد.

در زیر یک مثال از تابع abstract آورده شده است.

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

تعریف یک تابع به صورت abstract نتایج زیر را باعث میشود:

کلاسی که دارای این تابع است باید به صورت abstract تعریف شود.
هر کلاسی که از این کلاس ارث بری کند، یا باید تابع abstract را override کند، یا خودش به صورت abstract تعریف شود.

نکته: نتیجه آنکه، کلاس مشتق شده از کلاس abstract باید تابع abstract را پیاده سازی کند؛ مگر آنکه بخواهید سلسله مراتبی از کلاس های abstract داشته باشید که نمی توانند instantiate شوند.

فرض کنید کلاس Salary از کلاس Employee ارث بری کرده است، در این صورت کلاس Salary باید تابع computePay() را همانند زیر پیاده سازی کند:

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

   //Remainder of class definition
}