Relaties tussen klassen. Overerving, samenstelling en aggregatie

Hoi! Vandaag gaan we dieper in op één principe van Object Oriented Programming (OOP): Overerving. We zullen ook andere soorten relaties tussen klassen bestuderen: compositie en aggregatie. Dit onderwerp zal niet moeilijk zijn: u bent in vorige lessen al vele malen overerving en voorbeelden van overerving tegengekomen. Vandaag zal het belangrijkste zijn om uw kennis te versterken, het mechanisme van overerving in meer detail te onderzoeken en nogmaals enkele voorbeelden door te nemen. :) Nou laten we gaan!

Overerving op Java en de voordelen ervan

Zoals u zich ongetwijfeld herinnert, is overerving een mechanisme waarmee u een nieuwe klasse kunt beschrijven op basis van een bestaande klasse (ouderklasse). Daarbij leent de nieuwe klasse de eigenschappen en functionaliteit van de bovenliggende klasse. Laten we eens kijken naar een voorbeeld van overerving uit vorige lessen:

public class Car {

   private String model;
   private int maxSpeed;
   private int yearOfManufacture;

   public Car(String model, int maxSpeed, int yearOfManufacture) {
       this.model = model;
       this.maxSpeed = maxSpeed;
       this.yearOfManufacture = yearOfManufacture;
   }


public void gas() {
       // Gas
   }

   	public void brake() {
       // Brake
   }
}


public class Truck extends Car {

   public Truck(String model, int maxSpeed, int yearOfManufacture) {
       super(model, maxSpeed, yearOfManufacture);
   }
}



public class Sedan extends Car {
   public Sedan(String model, int maxSpeed, int yearOfManufacture) {
       super(model, maxSpeed, yearOfManufacture);
   }
}

We hebben een bepaald programma waarbij we met verschillende soorten auto's werken. Zelfs als je geen autoliefhebber bent, weet je waarschijnlijk dat er heel veel soorten auto's in de wereld zijn. :) Dienovereenkomstig zullen we de gemeenschappelijke eigenschappen van auto's scheiden in een gemeenschappelijke bovenliggende klasse genaamd Car. Dus wat hebben alle auto's gemeen, ongeacht hun type? Elke auto heeft een bouwjaar, modelnaam en maximale snelheid. We plaatsen deze eigenschappen in de model, maxSpeed, en yearOfManufacturevelden. Wat het gedrag betreft, kan elke auto accelereren en vertragen. :) We definiëren dit gedrag in de gas()enbrake()methoden. Welke voordelen levert dit ons op? Allereerst vermindert het de hoeveelheid code. We kunnen natuurlijk ook zonder de ouderklas. Maar aangezien elke auto moet kunnen accelereren en vertragen, zullen we gas()en brake()methoden moeten creëren in de klassen Truck, Sedan, F1Car, en SportsCaren in elke andere autoklasse. Stel je voor hoeveel extra code we zouden moeten schrijven. modelEn vergeet de velden , maxSpeed, en niet yearOfManufacture: als we de bovenliggende klasse verwijderen, moeten we deze in elke autoklasse maken! Als we een paar dozijn autoklassen hebben, wordt de hoeveelheid dubbele code echt serieus. Door gemeenschappelijke velden en methoden (ook wel "states" en "behaviors" genoemd) naar een bovenliggende klasse te verplaatsen, kunnen we veel tijd en ruimte besparen. Als een bepaald type unieke eigenschappen of methoden heeft die andere autotypes niet hebben, is dat geen probleem. Je kunt ze altijd in een afstammelingenklasse maken, gescheiden van alle anderen.

public class F1Car extends Car {

   public void pitStop() {

       // Only race cars make pit stops
   }

   public static void main(String[] args) {

       F1Car formula1Car = new F1Car();
       formula1Car.gas();
       formula1Car.pitStop();
       formula1Car.brake();
   }
}

Laten we als voorbeeld kijken naar Formule 1-raceauto's. In tegenstelling tot hun 'verwanten' hebben ze een uniek gedrag: ze maken van tijd tot tijd een pitstop. Dit stoort ons niet. We hebben het algemene gedrag in de Carbovenliggende klasse al beschreven en het specifieke gedrag van onderliggende klassen kan aan die klassen worden toegevoegd. Hetzelfde geldt voor velden: als een kindklasse unieke eigenschappen heeft, declareren we deze velden rustig binnen de kindklasse en maken we ons geen zorgen meer. :) De mogelijkheid om code opnieuw te gebruiken is het belangrijkste voordeel van overerving. Voor programmeurs is het erg belangrijk om geen extra code te schrijven. In je werk kom je dit vaker tegen. Onthoud alsjeblieft nog iets cruciaals: Java heeft geen meervoudige overerving. Elke klasse erft slechts één klasse. We zullen in toekomstige lessen meer vertellen over de redenen hiervoor. Voor nu, onthoud het gewoon. Dit maakt Java trouwens anders dan sommige andere OOP-talen. C++ ondersteunt bijvoorbeeld meerdere overerving. Alles is min of meer duidelijk met overerving. Laten we verder gaan.

Samenstelling en aggregatie

Klassen en objecten kunnen aan elkaar gekoppeld worden. Overerving beschrijft een "is-een" relatie. Een leeuw is een dier. Zo'n relatie wordt gemakkelijk uitgedrukt met behulp van overerving, waar Animalis de bovenliggende klasse en Lionis het kind. Niet alle relaties worden echter op deze manier beschreven. Een toetsenbord is bijvoorbeeld zeker gerelateerd aan een computer, maar het is geen computer . Handen zijn op de een of andere manier gerelateerd aan een persoon, maar ze zijn geen persoon. In deze gevallen hebben we een ander type relatie: niet "is-een", maar "heeft-een". Een hand is geen persoon, maar maakt deel uit van een persoon. Een toetsenbord is geen computer, maar maakt deel uit van een computer. Een heeft-een-relatie kan in code worden beschreven met behulp van compositie en aggregatie. Het verschil ligt in de "strengheid" van de relatie. Laten we een eenvoudig voorbeeld geven: we hebben een Carklas. Elke auto heeft een motor. Bovendien heeft elke auto passagiers. Wat is het fundamentele verschil tussen de velden Engine engineen Passenger[] passengers? Het feit dat een passagier Ain een auto zit, betekent niet dat er Bgeen passagiers Cin de auto zitten. Een auto kan overeenkomen met meerdere passagiers. Sterker nog, als alle passagiers uit een auto stappen, functioneert deze nog steeds probleemloos. De relatie tussen de Carklasse en de Passenger[] passengersarray is minder strikt. Aggregatie heet dat . Het is een ander goed voorbeeld van aggregatie. StudentStel dat we een klasse en een hebbenStudentGroupklas. Een student kan lid zijn van meerdere studentenorganisaties: een natuurkundeclub, een Star Wars-fanclub en/of een studentencomedyclub. Compositie is een strikter soort relatie. Bij gebruik van compositie maakt een object deel uit van een object en kan het niet behoren tot een ander object van hetzelfde type. Het eenvoudigste voorbeeld is een automotor. Een motor is onderdeel van een auto en kan geen onderdeel zijn van een andere auto. Zoals je kunt zien, is hun relatie veel strenger dan de relatie tussen Caren Passengers.