Java Abstract na Paraan at Mga Klase

Ang mga abstract na pamamaraan ay isang makapangyarihang tool ng Java at nagbibigay sa object-oriented na wika na ito ng higit pang mga kakayahan pagdating sa polymorphism. Ang isang abstract na pamamaraan ng Java ay maaaring gamitin upang lumikha ng isang pangunahing balangkas para sa isang buong programa at bigyang-daan kang mag-adjust kung kinakailangan.

Ano ang isang Abstract na Paraan?

Ang abstract na pamamaraan ay isang paraan na walang pagpapatupad. Ibig sabihin, mayroon lang itong deklarasyon, kaya alam mo ang pangalan, ang uri ng pagbabalik, at ang mga variable na tatanggapin nito. Narito ang isang halimbawa ng isang pangunahing abstract na pamamaraan:

public abstract int example(int a1, int a2);

Kapag tiningnan mo ang paraang ito, masasabi mong nagbabalik ito ng integer at tumatanggap ito ng dalawang integer bilang argumento nito. Ang hindi mo masasabi ay kung paano ipinatupad ang pamamaraang ito. Iyon ay dahil upang maipatupad ito, kailangan mong i-override ito. Kapag lumilikha ng abstract na pamamaraan sa java, kailangan mong sumunod sa ilang mga alituntunin o ang iyong programa ay hindi mag-compile ng tama. Tandaan:

• Ang mga abstract na pamamaraan ng Java ay walang pagpapatupad. Ibig sabihin, hindi sila dapat sundan ng mga kulot na braces at isang katawan na nagsasabi kung paano gagamitin ang pamamaraan. Ito ay nagtatapos lamang sa isang semicolon.

• Kung gagawa ka ng abstract na paraan, maaari lamang itong ilagay sa abstract na klase. Iyon ay, hindi ka maaaring magkaroon ng isang kongkretong klase na mayroong abstract na pamamaraan sa loob nito.
  i. Bilang isang side note, kung mayroon kang abstract class, maaari itong maglaman ng mga constructor. Hindi nito kailangang magkaroon ng abstract na pamamaraan, gayunpaman.

• Kapag ang isang kongkretong klase ay nagpalawak ng isang abstract na klase, dapat din itong ipatupad ang lahat ng abstract na pamamaraan ng parent class o hindi ito maaaring maging konkreto at dapat ideklarang abstract.

Ang huling dalawang iyon ay maaaring medyo nakakalito, kaya't i-clear natin iyon kaagad.

Pagpapalawak ng Abstract Java Classes

Sabihin nating gusto nating magsulat ng isang programa tungkol sa mga pangunahing hugis na magbabalik ng perimeter at lugar. Kaya gumawa kami ng abstract na klase ng magulang. Ngunit dahil ang bawat hugis ay may sariling mga patakaran, ang bawat isa ay dapat na kalkulahin nang iba, kaya isulat namin ang abstract na klase ng Shape tulad nito:

abstract class Shape {
  		String shapeName = " ";
  		Shape(String name) { 
    			this.shapeName = name; 
  		} 

abstract double area();
  		abstract double perimeter();
}

Ngayon, kung gusto nating aktwal na gamitin ang mga abstract na pamamaraan na ito, kailangan nating pahabain ang abstract Java parent class na Shape at pagkatapos ay i-instantiate ang mga pamamaraan. Kaya dapat ipatupad ng bawat kongkretong klase ang lugar at perimeter abstract na pamamaraan.

class Quadrilateral extends Shape  
{ 
    double length, width; 
      
    Quadrilateral(double l, double w, String name) 
    { 
        super(name); 
        this.length = l; 
        this.width = w; 
    } 
      
    @Override
    public double perimeter()  
    { 
        return ((2*length)+(2*width));
    } 
      
    @Override
    public double area()  
    { 
        return (length*width); 
    } 
}

Implementing the Quadrilateral class would then look like this
class Main
{ 
    public static void main (String[] args)  
    { 
      
        // creating a Quadrilateral object using Shape as reference 
        Shape rectangle = new Quadrilateral(3,4, "Rectangle"); 
        System.out.println("Area of rectangle is " + rectangle.area()); 
        System.out.println("Perimeter of rectangle is " + rectangle.perimeter());
  
    } 
} 

Ang output mula sa console ay ganito ang hitsura:

Area of rectangle is 12.0
Perimeter of rectangle is 14.0

Tandaan na ang klase Quadrilateral ay hindi kailangang mag-instantiate ng Shape(String name) constructor mula sa parent class na Shape . Iyon ay dahil hindi ito isang abstract na pamamaraan. Gayunpaman, kung nagpatupad ka lamang ng isang lugar o perimeter sa isang klase, ang bagong klase ay kailangang abstract dahil hindi ito kasama ang pareho. Maaari ka ring gumamit ng mga abstract na pamamaraan sa Mga Interface.

Mga Abstract na Pamamaraan ng Java na may Mga Interface

Mabilis nating suriin kung ano ang isang interface at kung paano ito naiiba sa isang abstract na klase. Sa isang interface, ang anumang mga variable na idineklara sa isang interface ay pampubliko, static, at pinal. Ang mga abstract na klase sa kabilang banda, mayroon lamang mga hindi panghuling variable. Ang lahat sa isang interface ay pampubliko bilang default. Ang isang abstract na klase ay maaaring magkaroon ng pribado, protektado, pampubliko, atbp. Sa wakas, ang isang klase ay hindi nagpapalawak ng isang interface, ito ay nagpapatupad nito. Bago ang JDK 8, ang isang interface ay hindi maaaring magkaroon ng anuman dito kundi ang mga abstract na pamamaraan. Ngayon, ang isang interface ay maaaring magkaroon ng mga default at static na pamamaraan. Dahil dito, ang pinakamahuhusay na kagawian ay lumayo mula sa paggamit ng mga abstract na pamamaraan bilang mga napapalawig na template at nakatutok sa Mga Interface at pagpapatupad ng mga ito. Kaya kung gagawa ka ng Shape bilang Interface at pagkatapos ay ipatupad ito bilang Quadrilateral, ano ang magiging hitsura nito? Una, kailangan mong alisin ang Shape(String name) constructor. Magiging ganito ito sa dalawang abstract na pamamaraan:

interface Shape {

  abstract double area();
  abstract double perimeter();
}


So the Quadrilateral class would then look like this:
class Quadrilateral implements Shape {  

  double length, width; 
      
    	  Quadrilateral(double l, double w) {
    
    	    this.length = l; 
    	    this.width = w; 
    	  } 
      
    	  @Override
    	  public double perimeter() {
     
    	    return ((2*length)+(2*width));
    	  } 
      
    	  @Override
    	  public double area() {
    
   	    return (length*width); 
    	  } 
}

Sa wakas, ang paggamit ng bagong Quadrilateral habang ipinapatupad nito ang interface ng Shape ay magiging magkapareho:

class Main
{ 
    public static void main (String[] args)  
    { 
      
        // creating a Quadrilateral object using Shape as reference 
        Shape rectangle = new Quadrilateral(3,4); 
        System.out.println("Area of rectangle is " + rectangle.area()); 
        System.out.println("Perimeter of rectangle is " + rectangle.perimeter());
  
    } 
}

At ang console print out ay magiging ganito:

Area of rectangle is 12.0
Perimeter of rectangle is 14.0

Kung gusto mong tuklasin ang higit pa tungkol sa mga pagkakaiba sa pagitan ng mga interface at abstract na mga klase, makakahanap ka ng higit pang impormasyon dito.

Ngunit Bakit Gumamit ng Mga Abstract na Paraan ng Java?

Maraming dahilan kung bakit ginagamit ang mga abstract na pamamaraan sa Java at kung bakit dapat kang maging komportable sa paggamit ng mga ito. Narito ang tatlong mabilis na dahilan kung bakit dapat mong gamitin ang mga ito kapag naaangkop ito.

1. Iwasan ang pagdoble ng mga pagsisikap – Balikan ang aming halimbawang coding; isipin na kailangan mo at ng iyong koponan na lumikha ng mga klase para sa mga hugis maliban sa isang parihaba. Gaano karaming iba't ibang paraan ang maaari mong gawin upang magdisenyo ng klase na iyon? sampu? Labinlima? At iyon ay isang simpleng problema. Isipin ang isang bagay na mas kumplikado. Ikaw at ang iyong koponan ay maaaring makabuo ng isang daang paraan. Pagkatapos ay mahaharap ka sa nakakatakot na gawain ng pagsasama-sama ng mga ito sa isang magkakaugnay na programa. Dinadala tayo nito sa susunod nating punto: pagtukoy sa pagpapatupad.

2. Ang mga Abstract na Paraan sa Java ay nagbibigay-daan sa kahulugan ng paggamit at pagpapatupad – Kapag gumamit ka ng abstract na klase o interface, at ayon sa disenyo, abstract na mga pamamaraan, tinutukoy mo kung paano makikipag-ugnayan ang ibang tao sa iyong interface. Iyon ay nagpapaalam sa kanila kung anong mga variable ang dapat nilang gamitin at kung anong mga uri ng pagbabalik ang maaari nilang asahan.
   Bagama't maaari nilang i-override ang mga ito at lumikha ng mga kongkretong klase na nagpapatupad ng iyong interface sa mga natatanging paraan, itinakda mo pa rin ang pangunahing paggamit para sa iyong code. Kung may gustong magpatupad ng Shape, kailangan nilang i-override o ipatupad ang parehong perimeter at area.

3. Readability at Debugging – Ang pagkakaroon ng abstract na mga pamamaraan ay magpapahusay sa pagiging madaling mabasa ng iyong code. Kapag sumulat ka ng isang klase na nagpapatupad ng isang interface, alam mo kung ano ang hahanapin. Alam mo na ang bawat abstract na paraan sa interface ay nasa pagpapatupad, at ginagawa nitong mas madaling basahin at subaybayan ang anumang mga bug. Ang mga abstract na pamamaraan ay simula pa lamang ng pag-aaral kung paano maayos na gamitin ang polymorphism sa Java at iba pang mga object-oriented na wika. Kapag sinimulan mong maunawaan at gamitin ang mga ito, magsisimula ang isang ganap na bagong kabanata ng iyong paglalakbay sa coding.