Rapporti tra classi. Ereditarietà, composizione e aggregazione

Ciao! Oggi daremo uno sguardo più da vicino a un altro principio della programmazione orientata agli oggetti (OOP): l'ereditarietà. Allo stesso tempo studieremo altri tipi di relazioni tra classi: composizione e aggregazione. Questo argomento non sarà difficile: hai già incontrato l'ereditarietà e i suoi esempi molte volte nelle lezioni precedenti. Oggi la cosa principale sarà consolidare le tue conoscenze, dare uno sguardo più da vicino al meccanismo dell'ereditarietà e passare ancora una volta agli esempi :) Quindi, andiamo!

Ereditarietà in Java e suoi vantaggi

Come probabilmente ricorderete, l'ereditarietà è un meccanismo che consente di descrivere una nuova classe basata su una classe esistente (genitore). In questo caso, le proprietà e le funzionalità della classe genitore vengono prese in prestito dalla nuova classe. Ricordiamo l'esempio dell'ereditarietà delle lezioni precedenti:

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

Esiste un determinato programma all'interno del quale lavoriamo con vari tipi di auto. Anche se non sei un appassionato di auto, probabilmente sai che esistono moltissimi tipi di queste stesse auto nel mondo :) Pertanto, separiamo le proprietà generali delle auto in una classe genitore comune - Car. Cosa hanno in comune tutte le auto, indipendentemente dal tipo? Ogni auto ha un anno di produzione, nome del modello e velocità massima. Inseriamo queste proprietà nei campi model, maxSpeed, yearOfManufacture. Per quanto riguarda il comportamento, qualsiasi macchina può accelerare e frenare :) Definiamo questo comportamento in metodi gas()e brake(). Quali vantaggi ci offre questo? Innanzitutto riducendo la quantità di codice. Naturalmente possiamo fare a meno della classe genitore. Ma poiché ogni auto deve essere in grado di accelerare e frenare, dovremo creare metodi gas()in brake()the class Truck, in the class Sedan, in the class F1Car, in the class Sportcare in tutte le altre classi di auto. Immagina quanto codice extra scriveremo in questo caso. Non dimenticare i campi model, maxSpeed ​​e yearOfManufacture: se abbandoniamo la classe genitore, li creeremo in ciascuna delle classi macchina! Quando avremo un paio di dozzine di classi macchina, la quantità di codice ripetitivo diventerà davvero seria. Lo spostamento di campi e metodi comuni (chiamati anche “stato” e “comportamento”) nella classe genitore ci consentirà di risparmiare molto tempo e spazio. Se un certo tipo ha proprietà o metodi unici solo per esso e assenti in altri tipi di macchine, non importa. Possono sempre essere creati in una classe discendente, separatamente da tutte le altre.

public class F1Car extends Car {

   public void pitStop() {

       //...only racing cars make pit stops
   }

   public static void main(String[] args) {

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

Prendiamo il caso delle auto da corsa di Formula 1. Loro, a differenza dei loro "parenti", hanno un comportamento unico: di tanto in tanto fanno un pit stop. Questo non ci disturba. Abbiamo già descritto il comportamento generale della classe genitore Care possiamo aggiungere il comportamento specifico delle classi figlie all'interno delle classi. Questo vale anche per i campi: se una classe figlia ha proprietà uniche, possiamo tranquillamente dichiarare questi campi al suo interno e non preoccuparci :) La possibilità di riutilizzare il codice è il vantaggio principale dell'ereditarietà. È molto importante per un programmatore non scrivere quantità inutili di codice. Lo incontrerai più di una volta nel tuo lavoro. Ricorda un'altra cosa molto importante: non esiste l'ereditarietà multipla in Java. Ogni classe eredita da una sola classe. Parleremo delle ragioni di ciò in modo più dettagliato nelle lezioni future, ma per ora ricordatelo. Questo, tra l'altro, distingue Java da altri linguaggi OOP. Ad esempio, C++ ha ereditarietà multipla. Tutto è più o meno chiaro con l'ereditarietà: andiamo avanti.

Composizione e aggregazione

Classi e oggetti possono essere correlati tra loro. L'ereditarietà descrive la relazione "è" (o in inglese "IS A"). Il Leone è un animale. Questa relazione può essere facilmente espressa utilizzando l'ereditarietà, dove Animalla classe sarà il genitore e Lionla classe sarà il figlio. Tuttavia, non tutte le relazioni nel mondo sono descritte in questo modo. Ad esempio, una tastiera è sicuramente collegata in qualche modo a un computer, ma non è un computer . Le mani sono in qualche modo connesse alla persona, ma non sono la persona. In questi casi si basa su un diverso tipo di relazione: non “è”, ma “è parte” (“HAS A”). La mano non è una persona, ma è parte di una persona. La tastiera non è un computer, ma è parte del computer. Le relazioni HA A possono essere descritte nel codice utilizzando meccanismi di composizione e aggregazione . La differenza tra loro sta nella “rigore” di queste connessioni. Facciamo un semplice esempio: abbiamo la nostra Car: un'auto. Ogni macchina ha un motore. Inoltre, ogni macchina ha dei passeggeri all'interno. Qual è la differenza fondamentale tra campi Engine enginee Passenger [] passengers? Se un'auto ha un passeggero a bordo А, ciò non significa che non possano esserci passeggeri a Bbordo C. Un'auto può ospitare più passeggeri. Inoltre, se tutti i passeggeri vengono fatti scendere dall'auto, questa continuerà a funzionare silenziosamente. Il rapporto tra classe Care massa dei passeggeri Passenger [] passengersè meno stretto. Si chiama aggregazione . C'è un buon articolo su questo argomento: Relazioni tra classi (oggetti) . Fornisce un altro buon esempio di aggregazione. Diciamo che abbiamo una classe Studentche indica uno studente e una classe StudentsGroup(un gruppo di studenti). Uno studente può essere membro di un club di fisica, di un fan club studentesco di Star Wars o di una squadra KVN. La composizione è un tipo di comunicazione più rigoroso. Quando si utilizza la composizione, non solo un oggetto è parte di un oggetto, ma non può appartenere a un altro oggetto dello stesso tipo. L'esempio più semplice è il motore di un'auto. Un motore fa parte di un'auto, ma non può far parte di un'altra auto. Come puoi vedere, la loro connessione è molto più stretta di quella di Care Passengers.