Concetto di astrazione in OOP

Nella programmazione funzionale, esiste un concetto chiamato Mappa. La mappa è una funzione di ordine superiore che applica una funzione a ciascun elemento di un elenco.

Nel codice normale, dovresti fare qualcosa come:

var list = new List<int> { 1,2,3,4,5,6 };

var newList = new List<int>();

foreach(var item in list)
{
    newList.Add(item * 2);
}

// newList --> { 2,4,6,8,10,12 }

Invece di scrivere un ciclo ogni volta, crei un metodo Mappa:

public List<T> Map<T>(this List<T> list, Func<T,TResult> function)
{
    var newList = new List<T>()

    foreach(T item in enumeration)
    {
        newList.Add(function(item));
    }

    return newList;
}

Ora, invece di scrivere un ciclo ogni volta, puoi semplicemente scrivere:

var list = new List<int>() { 1,2,3,4,5,6 };

var modifiedList = Map(list, x => x * 2); // { 2,4,6,8,10,12 }

e ottieni lo stesso risultato.

Il metodo Map è un'astrazione sulla scrittura di un ciclo per modificare ciascun membro di una lista.

Non l'ho ancora menzionato, ma la sintassi <T> è anche un'astrazione. Si chiama generici; significa che puoi scrivere una funzione che può operare su diversi tipi di dati, invece di scrivere funzioni per ogni tipo di dati.

Tutta l'astrazione è una forma di generalizzazione: scrivere un codice che si applica a più di una situazione specifica.

I hear that Abstraction is a technique that helps us identify which specific information should be visible, and which information should be hidden.

sbagliato. Questo fa ancora parte dell'incapsulamento.

L'astrazione si ha quando si hanno più comportamenti intercambiabili che vengono manipolati attraverso l'interfaccia comune. La cosa multipla è la cosa più importante. In OOP, le astrazioni vengono principalmente ottenute attraverso l'ereditarietà con metodi o interfacce virtuali e la loro realizzazione.

Bene, spiegherò l'astrazione con un esempio reale. Dite che nella vostra casa avete una presa elettrica e molti dispositivi possono connettersi alla stessa presa ma la spina non avrà mai un'idea di quale dispositivo sia collegato, in altre parole i dettagli dei dispositivi sono astratti (nascosti) alla spina.

Pensa cosa succede se colleghiamo un dispositivo direttamente al cavo elettrico senza una presa? Supponiamo di collegare una lampadina direttamente a un filo, quindi il filo sa a quale dispositivo è collegato e, quando mai abbiamo bisogno di sostituire la lampadina, dobbiamo rimuovere il cavo dalla lampadina, il che significa che la lampadina è strettamente accoppiata al filo. In altre parole, bulbo e filo conoscono i dettagli a cui è collegato, non sono astratti.

Nell'astrazione mondiale orientata agli oggetti funziona esattamente allo stesso modo. La classe che consuma altre classi funzione / proprietà non ha bisogno di sapere quali classi funzione / proprietà sta consumando e tutto dovrebbe essere astratto con un'interfaccia / classe astratta.

Fammi codice nello stesso esempio. Qui ho una classe "ElectricPlug", che è in esecuzione un dispositivo. Ma la classe "ElectricPlug" non ha idea di quale dispositivo sia in esecuzione. Può essere qualsiasi classe che implementa l'interfaccia "IDevice", il che significa che l'implementazione di "RunDevice" è stata estratta da "ElectricPlug". Ecco il codice di esempio completo, 'inserisci il codice qui,

class Program
{
    static void Main(string[] args)
    {
        ElectricPlug electricPlug = new ElectricPlug(new Bulb());
    }
}

public class ElectricPlug
{
    private readonly IDevice _device;
    public ElectricPlug(IDevice device)
    {
        _device = device;
    }

    public void Run()
    {
        _device.Rundevice();
    }
}


public interface IDevice
{
    void Rundevice();
}


public class Bulb : IDevice
{
    public void Rundevice()
    {
       Console.WriteLine("Switched on bulb");
    }
}

In parole semplici:

Scrivere una soluzione con OOP è come creare un modello del problema, rendendo il problema più semplice, permettendo così di scrivere soluzioni sufficientemente buone.

Ma non abbiamo bisogno di modellare il tutto fino ai dettagli più minuti, perché il modello sarebbe tanto complesso quanto il problema stesso. Sarebbe come creare una mappa con una scala di 1: 1. Tale mappa sarebbe grande quanto la cosa reale.

Creiamo un modello semplificato con le cose che sono cruciali per la soluzione. Riassumendo noi stessi dalle minuzie, non diversamente dalle sospensioni di un veicolo, il guidatore astrae dalle irregolarità della strada.

Si chiama generalizzazione, o astrazione.

Quando hai veramente bisogno di fare qualcosa di molto specifico, fai il contrario: ottieni la soluzione generale e ti costruisci sopra. Si chiama specializzazione.

Non scrivere codice che ordina un array di nomi di persone.

Scrive codice che ordina una serie di stringhe. È abbastanza generico per ordinare nomi di persone, nomi di paesi e nomi scientifici di animali.

Concrete-man (personaggio immaginario) avrebbe scritto metodi di ordinamento diffusi che fanno quasi la stessa cosa.

L'astrazione di solito si svolge su una lavagna, un tovagliolo o la mente del progettista.

Quando scrivi il codice, il processo di astrazione è già avvenuto.

L'astrazione è il processo per decidere quali classi hanno in comune.

La maggior parte delle volte non ha nemmeno a che fare con il codice.