Una guida per principianti all’astrazione nella programmazione orientata agli oggetti

Quando mangi un burrito, ognuno dei tuoi recettori del gusto canta di gioia. Ogni boccone porta una combinazione di diversi tipi di sapore, come salato, dolce, piccante e umami. Ogni boccone dopo ha un sapore leggermente diverso poiché una nuova collezione di ingredienti unisce i loro sapori.

Potresti aver letto gli ingredienti dal menu, ma non sai esattamente come viene preparata la salsa. Il condimento che usano sulle loro verdure potrebbe essere una miscela segreta. Tuttavia, non è necessario conoscere ogni ingrediente esatto. Basta sapere che è delizioso.

Gli ingredienti che conosci, come il semplice riso bianco, sono concreti. Gli altri elementi sono astratti. Sai che è salsa, ma di che tipo? Oppure, se qualcuno ti porge un burrito dal nulla, allora l'intero burrito è astratto.

Astrazione in astratto

Insieme all'ereditarietà , l'astrazione è un concetto importante nella programmazione orientata agli oggetti. La teoria è che ogni oggetto dovrebbe fornire risultati semplici e prevedibili. Gli oggetti dovrebbero anche condividere solo ciò che deve essere condiviso.

L'astrazione mantiene il codice e i dati nascosti quando appropriato

Puoi pensare a un burrito come a un oggetto. All'interno del burrito ci sono molti altri oggetti, come fagioli, riso, formaggio e salsa piccante. I fagioli potrebbero essere stati conditi. Il formaggio potrebbe essere una miscela. E la salsa piccante potrebbe essere una combinazione di peperoni invecchiati in aceto.

Non è necessario sapere come sono stati preparati tutti gli ingredienti di un burrito. E nel caso degli hot dog, probabilmente non lo vuoi sapere. Tutto ciò che conta è che non si sfaldi quando lo mangi e che sia super gustoso.

L'astrazione è strettamente legata all'incapsulamento

È la stessa cosa con la programmazione di oggetti. Quando installi un oggetto (lo crei da una classe), è come ordinare un burrito dal bancone del camioncino. Hai accesso ad alcuni dati, ma non a tutti. Non è necessario sapere come funziona l'oggetto, purché le funzioni restituiscano i dati corretti. Ecco un burrito in JavaScript / Typescript:

 class CheeseBlend {
private _ingredients = ["Colby Jack", "Cheddar", "Manchego"];
get ingredients() {
return "melted cheese";
}
}
class SecretSalsa {
private _ingredients = ["onions", "tomatoes", "cilantro", "Guatemalan Insanity Peppers"];
get ingredients() {
return "it's a secret";
}
}
class Burrito {
private _beans = "beans";
private _rice = "rice";
private _cheese: CheeseBlend = new CheeseBlend();
private _salsa: SecretSalsa = new SecretSalsa();
get cheese() {
return this._cheese.ingredients;
}
get salsa() {
return this._salsa.ingredients;
}
}
let burro = new Burrito();
console.log(burro.cheese);
console.log(burro.salsa);

Puoi giocare con questo codice nella sandbox TypeScript .

Nell'esempio precedente, gli ingredienti di salsa e formaggio vengono estratti. In primo luogo, sono incapsulati, per nascondere gli ingredienti speciali. Quindi vengono aggiunti getter per accedere agli ingredienti. Ma gli ingredienti restituiscono solo una rappresentazione astratta di ciò che sono realmente.

Astrazione nel cemento

abstract food - Una guida per principianti all’astrazione nella programmazione orientata agli oggetti

L'astrazione è però più di un concetto. Le classi possono anche essere astratte. Ciò significa che possono definire altre classi. Ma non possono essere istanziati da soli.

Perché a volte le classi dovrebbero essere astratte

Immagina di andare in un ristorante e di sederti. Il cameriere ti porge un menu. Lo apri per scoprire che c'è un solo oggetto: il cibo.

È abbastanza astratto. Lo ordineresti? Lo mangeresti? Probabilmente non lo faresti. Dire che qualcosa è cibo non è sufficiente. Ha bisogno di essere scomposto in qualcosa di più concreto.

E la pasta? Bene, questo è un tipo di cibo più specifico. E sappiamo che probabilmente ha pasta e salsa. Ma ci sono molti diversi tipi di pasta là fuori, quindi è ancora astratto.

Cosa è astratto e cosa è concreto?

Le Fettuccine Alfredo sono un esempio concreto sia di cibo che di pasta. La stessa cosa vale per le classi. Non tutte le classi dovrebbero essere istanziate. Alcune classi dovrebbero definire solo la struttura di altre classi.

Ecco un esempio con una classe alimentare astratta e una classe MacadamiaNuts bambino:

 abstract class Food {
constructor(public name: String) {}
abstract totalCalories(): number;
abstract description(): string;
abstract flavor(): string;
}
class MacadamiaNuts extends Food {
constructor() {
super("One Cup of Macadamia Nuts");
}
totalCalories() {
return 962;
}
description() {
return "A nut from Hawaii.";
}
flavor() {
return "rich, buttery, and nutty";
}
}
let nuts = new MacadamiaNuts();
console.log(nuts.name)
console.log(nuts.description())

Ecco il codice.

Le classi astratte dicono alle altre classi come dovrebbero comportarsi. Nell'esempio sopra, se stai per essere una classe di cibo, devi avere funzioni che consentono l'accesso al tuo nome, sapore, descrizione e calorie.

Si noti che la classe MacadamiaNuts estende Food . Ciò significa che MacadamiaNuts accetta di seguire le regole del cibo . Inoltre, nota che il costruttore chiama super . Quel comando crea un'istanza della classe padre prima che il costruttore crei un'istanza di MacadamiaNuts .

Se stai imparando a programmare, puoi divertirti di più con questi giochi di programmazione .

Pratica di astrazione

  • Visita il link sopra e usa la sandbox per creare una classe astratta chiamata Soup.
  • Crea un bambino concreto della classe Soup , chiamato Cereal .
  • Usa console.log per testare il tuo codice. Cosa succede se nella tua classe Cereal manca una delle funzioni definite in Soup ?

Ma qual è il punto di una classe che non puoi istanziare?

All'inizio, le lezioni astratte possono sembrare inutili. Dopotutto, non puoi effettivamente usarli per creare un oggetto. E non è che tramandano le loro funzioni. Le funzioni devono essere riscritte in ogni classe figlia.

Ci sono due ragioni principali per cui hai bisogno di classi astratte. Mantengono il codice coerente e si assicurano che anche altri sviluppatori scrivano codice coerente. Non lavorerai sempre da solo. L'intera squadra deve seguire le stesse regole. Puoi imparare di più dalla documentazione di TypeScript sulle classi astratte .