Absztrakt osztályok

"Szia, Amigo! Lenyűgöző új témánk van."

"A mai nap csak a lenyűgöző témák napja!"

"Miért köszönjem meg!"

"Szívesen."

"Emlékszel, amikor bevezettük a ChessItem alaposztályt, hogy leegyszerűsítsük a sakkfigurák összes osztályát?"

"Igen."

"Most képzeld el, hogy minden darabnak van egy metódusa, amely kezeli a darab megjelenítését a képernyőn. Meghívod a metódust, és a darab megrajzolja magát az aktuális koordinátáin. Hasznos lenne áthelyezni ezt a metódust az alaposztályba?"

"Igen." Miután megismertem a polimorfizmust, meg tudom hívni a renderelési metódust az összes darabhoz, függetlenül azok típusától. Valami ilyesmi:"

class ChessBoard
{
  public void drawAllChessItems()
  {
  //draw them regardless of their type.
  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();
  }
 }
}

"Jól van. Pontosan. És mit csinálna magának a ChessItem osztály húzási módszere?"

"Nem tudom. A sakknak nincs ilyen bábuja. Ez azt jelenti, hogy nincs vizuális ábrázolása."

"Pontosan. És nincs értelme ChessItem objektumot létrehozni. Nincs ilyen sakkfigura. Ez csak egy absztrakció – egy osztály, amelyet a kényelem kedvéért készítettünk. Így működik az absztrakció az OOP-ban: minden fontosat áthelyeztünk (megosztott) minden figura szerint) az adatokat és metódusokat egy alaposztályba , de megtartottuk a különbségeiket az egyes sakkfiguráknak megfelelő osztályokban."

A Java-nak erre van egy speciális osztálytípusa: az absztrakt osztály . Íme három dolog, amit érdemes megjegyezni az absztrakt osztályokkal kapcsolatban.

1) Egy absztrakt osztály deklarálhat metódusokat anélkül, hogy implementálná azokat. Az ilyen módszert absztrakt módszernek nevezzük.

 public abstract class ChessItem
{
 public int x, y; //coordinates
 private int value; //the piece's "value"

 public int getValue() //an ordinary method, returns value
 {
   return value;
 }

 public abstract void draw(); //abstract method. There is no implementation.

}

2) Egy absztrakt módszert az abstract kulcsszóval jelölünk .

Ha egy osztálynak csak egy absztrakt metódusa van, akkor az osztályt is abstract jelöli .

3) Nem hozhat létre objektumokat egy absztrakt osztályból. Az ezt megkísérlő kód egyszerűen nem fordítható le.

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

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

4) Ha az osztályod egy absztrakt osztályt örököl, akkor felül kell bírálnod az összes örökölt absztrakt metódust, azaz implementálnod kell őket. Ellenkező esetben az osztályát is elvontnak kell nyilvánítani. Ha az osztálynak csak egy implementálatlan metódusa van közvetlenül az osztályban deklarálva vagy a szülőosztálytól örökölt, akkor az osztály absztraktnak számít.

"De miért van szükség erre? Miért van szükségünk absztrakt osztályokra? Nem lehet helyette közönséges osztályokat használni? És az absztrakt metódusok helyett nem hozhatunk létre üres implementációkat, amelyek göndör zárójelek nyitásából és bezárásából állnak?"

De ezek a korlátozások olyanok, mint a privatemódosító. A módosítót arra használjuk, privatehogy szándékosan blokkoljuk az adatokhoz való közvetlen hozzáférést, hogy más programozók és osztályaik használják a módszereinket public.

Ugyanez vonatkozik egy absztrakt osztályra is. Aki írta az osztályt, nem akarja, hogy bárki is létrehozzon példányokat az osztályból. Éppen ellenkezőleg, a szerző elvárja, hogy elvont osztályának absztrakt metódusait örököljék és felülírják.

– Még mindig nem értem, miért akarjuk így bonyolítani az életünket.

"Ennek a funkciónak az előnye nyilvánvaló a nagy projektekben. Minél több osztályod van, annál világosabban kell körülhatárolnod a szerepüket. Látni fogod ennek előnyeit, és hamarosan. Ezen mindenkinek át kell mennie."