Abstracte lessen

"Hallo, Amigo! We hebben een fascinerend nieuw onderwerp."

"Vandaag is gewoon een dag vol fascinerende onderwerpen!"

"Waarom zou ik jou bedanken!"

"Graag gedaan."

"Weet je nog toen we de basisklasse ChessItem introduceerden om alle klassen voor schaakstukken te vereenvoudigen?"

"Ja."

"Stel je nu voor dat elk stuk een methode heeft die ervoor zorgt dat het stuk op het scherm wordt weergegeven. Je roept de methode aan en het stuk tekent zichzelf op de huidige coördinaten. Zou het nuttig zijn om deze methode naar de basisklasse te verplaatsen?"

"Ja." Nadat ik over polymorfisme heb geleerd, zou ik de rendermethode voor alle stukken kunnen aanroepen, ongeacht hun type. Iets zoals dit:"

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

"Goed gedaan. Precies. En wat zou worden gedaan door de methode draw van de klasse ChessItem zelf?"

'Ik weet het niet. Schaken heeft zo'n stuk niet. En dat betekent dat het geen visuele voorstelling heeft.'

"Precies. En het heeft geen zin om een ​​ChessItem-object te maken. Zo'n schaakstuk bestaat niet. Het is alleen een abstractie — een klasse die we voor het gemak hebben gemaakt. Zo werkt abstractie in OOP: we hebben alle belangrijke (gedeelde) door alle stukken) gegevens en methoden in een basisklasse , maar we hielden hun verschillen in de klassen die overeenkomen met specifieke schaakstukken."

Java heeft hiervoor een speciaal klassetype: de abstracte klasse . Hier zijn drie dingen om te onthouden over abstracte klassen.

1) Een abstracte klasse kan methoden declareren zonder ze te implementeren. Zo'n methode wordt een abstracte methode genoemd.

 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) Een abstracte methode wordt gemarkeerd met het trefwoord abstract .

Als een klasse ook maar één abstracte methode heeft, wordt de klasse ook gemarkeerd met abstract .

3) U kunt geen objecten van een abstracte klasse maken. Code die dit probeert, compileert gewoon niet.

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

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

4) Als uw klasse een abstracte klasse erft, moet u alle overgeërfde abstracte methoden overschrijven, dwz u moet ze implementeren. Anders moet je klas ook abstract verklaard worden. Als de klasse zelfs maar één niet-geïmplementeerde methode heeft die rechtstreeks in de klasse is gedeclareerd of is geërfd van de bovenliggende klasse, wordt de klasse als abstract beschouwd.

"Maar waarom is dit allemaal nodig? Waarom hebben we abstracte klassen nodig? Is het niet mogelijk om in plaats daarvan gewone klassen te gebruiken? En kunnen we in plaats van abstracte methoden niet gewoon lege implementaties maken die bestaan ​​uit het openen en sluiten van accolades?"

"Dat zou kunnen. Maar deze beperkingen zijn als de privatemodifier. We gebruiken de privatemodifier om opzettelijk directe toegang tot gegevens te blokkeren, zodat andere programmeurs en hun klassen onze publicmethoden gebruiken."

Hetzelfde geldt voor een abstracte klasse. Degene die de klasse heeft geschreven, wil niet dat iemand instanties van de klasse maakt. Integendeel, de auteur verwacht dat de abstracte methoden van zijn of haar abstracte klasse worden geërfd en opgeheven.

"Ik begrijp nog steeds niet waarom we ons leven zo ingewikkeld zouden willen maken."

"Het voordeel van deze functie is duidelijk in grote projecten. Hoe meer klassen je hebt, hoe duidelijker je hun rollen moet afbakenen. Je zult het voordeel hiervan zien, en binnenkort. Iedereen moet dit doormaken."