Scorri per mostrare il menu

Astrazione

Siamo arrivati all’ultimo, ma molto importante, principio della programmazione orientata agli oggetti (OOP): l’astrazione. La parola "astrazione" può sembrare piuttosto astratta e, in breve, questo principio ci dice che dovremmo dipendere dall’astrazione piuttosto che da una specifica implementazione. Tuttavia, questo potrebbe sembrare complesso al momento. Iniziamo osservando la definizione:

Ad esempio, abbiamo una classe chiamata Person, e molte altre classi vengono derivate da essa. Person possiede vari campi e metodi comuni a tutte le classi. Tuttavia, quando abbiamo una classe chiamata BasketballPlayer,, la caratteristica height diventa fondamentale, mentre per una classe come Driver, height è irrilevante e non importante. È qui che entra in gioco l’astrazione. Ereditando da un’astrazione, possiamo rendere il parametro height opzionale, così non siamo obbligati a utilizzarlo dove non è necessario.

Potrebbe sembrare complesso, quindi passiamo a un esempio:

Car.java


              123456789
            
public abstract class Car {
    String model;
    int year;
    int maxSpeed;
    String color;
    
    public abstract void move();
    public abstract void stop();
}

La classe Car non rappresenta qualcosa di specifico. Non esiste semplicemente una Car; esistono berline, camion, trattori. Pertanto, dipenderemo dall'astrazione chiamata Car. Per semplificare ulteriormente: Car è un modello su cui vengono create classi di auto specifiche.

Presta attenzione alla sintassi:

public abstract class className{ }.

Questa è la sintassi per dichiarare una classe astratta. Nota anche la sintassi per dichiarare un metodo astratto:

public abstract returnValue methodName();

Un metodo astratto non ha un corpo; questa è la sua caratteristica principale. Le sottoclassi di una classe astratta sovrascriveranno questo metodo astratto per definire la propria implementazione, utilizzando il polimorfismo.

Analizziamo più da vicino cosa sia una classe astratta:

Nota che non è possibile creare un oggetto di una classe astratta; ciò genererà un errore:

Le classi astratte ci liberano dal trattare solo con "oggetti"; ci forniscono uno stato di base e un comportamento. Prendendo l'esempio delle automobili, ogni automobile dovrebbe avere un modello, anno di produzione, velocità massima e colore. Dovrebbero anche essere in grado di muoversi e fermarsi. Tutto qui; da questo punto, progetterai le tue classi specifiche basandoti su questo schema astratto.

Regole per la Creazione di una Classe Astratta

Una classe astratta è una classe che contiene almeno un metodo astratto. Puoi creare una classe astratta senza alcun metodo astratto, ma in tal caso non avrebbe uno scopo. Non potrai istanziare oggetti di una classe astratta;
I metodi astratti possono esistere solo all'interno di una classe astratta; non puoi creare metodi astratti al di fuori di una classe astratta;
I metodi all'interno di una classe astratta possono essere sia metodi astratti che metodi con implementazione;
Una classe che eredita da una classe astratta deve sovrascrivere tutti i metodi astratti;
Puoi ereditare da un massimo di una classe (astratta o non astratta);
Una classe astratta dovrebbe rappresentare le proprietà e i comportamenti comuni delle sue classi derivate. Approfondiremo questo aspetto quando studieremo i principi SOLID.

Consideriamo un esempio per comprendere come le sottoclassi dovrebbero sovrascrivere i metodi astratti ereditando da una classe astratta, utilizzando l'esempio della classe figlia Truck:

Ecco il codice dallo screenshot, riscritto per una migliore leggibilità e chiarezza:

Car.java

Truck.java

Main.java


              123456789
            
public abstract class Car {
    String model;
    int year;
    int maxSpeed;
    String color;
    
    public abstract void move();
    public abstract void stop();
}

Esaminiamo più da vicino quanto scritto sopra nel dettaglio:

Prima slide: Stiamo creando una sottoclasse Truck che erediterà dalla classe astratta Car. Possiamo vedere che l'IDE ci suggerisce di implementare i metodi richiesti;
Seconda slide: Stiamo sovrascrivendo i metodi necessari. Ad esempio, scriveremo che il Truck ha iniziato a muoversi e poi si è fermato;
Terza slide: Creiamo un oggetto nel metodo main. Presta attenzione alla sintassi utilizzata: Car name = new Truck();. Iniziamo a creare l'oggetto tramite astrazione e concludiamo con un'implementazione specifica. Questo si chiama composizione. Successivamente, assegniamo i valori ai campi secondo necessità e richiamiamo i metodi sovrascritti.

Voilà! Se hai compreso tutto, hai imparato come utilizzare una classe astratta!

Riepilogo

L'astrazione è probabilmente il principio più impegnativo dell'OOP da comprendere, ed è molto probabile che tu non abbia afferrato tutto in questo momento. Ma non pensare di essere solo in questo. L'astrazione è un concetto che inizialmente risulta difficile da comprendere per la maggior parte degli sviluppatori. Col tempo, capirai meglio come lavorare efficacemente con l'astrazione e le classi astratte. L'astrazione è un principio fondamentale perché ci permette di rendere i nostri programmi estensibili e altamente flessibili.