Mga abstract na klase

1. Karaniwang baseng klase

Ngayon ay mag-e-enjoy kami sa maraming kawili-wiling paksa. Tandaan noong ipinakilala namin ang ChessItembatayang klase upang gawing simple ang lahat ng mga klase na kumakatawan sa mga piraso ng chess? Sana 🙂

Ngayon isipin na ang bawat piraso ay may isang draw()paraan na humahawak sa pagguhit nito sa screen. Tinatawag mo ang draw()pamamaraan, at ang piraso ay gumuhit mismo sa kasalukuyang mga coordinate nito. Magiging maginhawa upang ilipat ang pamamaraang ito sa base class.

Kung ang draw()pamamaraan ay nasa baseng klase ng ChessItem, maaari nating i-override ito sa mga klase ng piraso at magsulat ng eleganteng code tulad nito:

class ChessBoard
{
   public void drawAllChessItems()
   {
      // Add the pieces to the list
      ArrayList<ChessItem> items = new ArrayList<ChessItem>();
      items.add(new King());
      items.add(new Queen());
      items.add(new Bishop());

      // Draw them regardless of their type
      for(ChessItem item: items)
      {
         item.draw();
      }
   }
}

Sa pamamagitan ng pagpapakilala ng ChessItembase class, nagawa naming lubos na gawing simple ang code: hindi na kailangang tawagan ang mga pamamaraan ng bawat klase nang hiwalay, madali naming maiimbak ang lahat ng mga bagay sa isang solong koleksyon, atbp.

Ngunit narito ang isang kawili-wiling tanong: ano ang dapat na draw()direktang ipahayag ng pamamaraan sa ChessItemklase sa screen? Kung tutuusin, walang ganoong piyesa sa chess, kaya walang mabubunot.

Tamang tama yan. Higit pa rito, walang saysay na lumikha ChessItemng mga bagay nang direkta. Ito ay hindi isang piraso ng chess, ngunit sa halip ay isang abstraction lamang — isang klase na ginawa namin para sa aming kaginhawahan. Ito ay kung paano gumagana ang abstraction sa OOP : inililipat namin ang mahalagang data at mga pamamaraan (mga ibinahagi ng lahat ng piraso) sa isang base class, at pinapanatili ang kanilang mga pagkakaiba sa magkakahiwalay na mga descendant na klase.

2. Abstract na mga klase

Para sa mga ganitong sitwasyon, may espesyal na uri ng klase ang Java: ang abstract class . Idinisenyo ang mga ito upang gawing mas madali para sa mga programmer na magtrabaho kasama ang mga katulad na klase at bawasan ang dami ng nadobleng code sa mga ito.

Narito ang tatlong bagay na dapat malaman tungkol sa mga abstract na klase.

Paraan na walang pagpapatupad

Ang isang abstract na klase ay maaaring magkaroon ng deklarasyon ng pamamaraan nang walang pagpapatupad. Ito mismo ang gumagawa ng paraan na abstract. Ang katawan ng pamamaraan ay pinapalitan lamang ng isang semicolon. At bago ang pangalan ng pamamaraan, isinulat namin ang abstractkeyword. Halimbawa:

public abstract class ChessItem
{
   public int x, y; // Coordinates
   private int value; // The piece's value
   public int getValue() // Ordinary method that returns value field
   {
      return value;
   }

   public abstract void draw(); // Abstract method. The implementation is missing.
}

Abstract na klase

Ang bawat pamamaraan na walang pagpapatupad ay minarkahan ng abstract na keyword. Kung ang isang klase ay may kahit isang abstract na pamamaraan, ang klase ay minarkahan din ng abstractkeyword.

Ipinagbabawal ang paglikha ng mga bagay

Hindi ka makakagawa ng mga bagay ng abstract na klase . Ang ganitong code ay hindi lang mag-compile.

ChessItem item = new ChessItem();
item.draw();

ChessItem item = new Queen();
item.draw();

Pagpapamana ng abstract na klase

Kung nagmamana ang iyong klase ng abstract na klase, kailangan mong i-override ang lahat ng minanang abstract na pamamaraan, ibig sabihin, kailangan mong magsulat ng pagpapatupad para sa kanila. Kung hindi, ang iyong klase mismo ay kailangan ding ideklarang abstract.

Kung ang isang klase ay may kahit isang hindi ipinatupad na pamamaraan na direktang ipinahayag dito o minana mula sa isang parent na klase, kung gayon ang klase ay itinuturing na abstract.

At bakit kailangan ang lahat ng ito? Bakit kailangan ang mga abstract na klase? Hindi ba pwedeng gumamit ng mga ordinaryo sa halip? At sa halip na abstract na mga pamamaraan, hindi ba tayo magsulat ng dalawang walang laman na kulot na bracket bilang katawan ng pamamaraan?

kaya namin. Ngunit ang mga paghihigpit na ito ay katulad ng privatemodifier. Ginagamit namin ang pribadong keyword upang sadyang pigilan ang ibang programmer na direktang ma-access ang data at upang pilitin silang gamitin lamang ang aming mga pampublikong pamamaraan kapag nagsusulat ng kanilang mga klase.

Ito ay pareho sa mga abstract na klase. Ang may-akda ng isang abstract na klase ay hindi nais na malikha ang mga bagay ng klase. Sa halip, inaasahan ng may-akda na ang mga abstract na pamamaraan ay minana mula sa abstract na klase at pagkatapos ay ma-override.

Ang bentahe ng pamamaraang ito ay madaling makita sa malalaking proyekto. Kung mas maraming klase ang mayroon ka, mas malinaw na kailangan mong ilarawan ang kanilang mga tungkulin. Makikita mo ang pakinabang ng diskarteng ito sa malapit na hinaharap. Lahat ng bagay ay dumadaan dito.