Esaminare la struttura dei programmi orientati agli oggetti

11 minuti

La programmazione orientata agli oggetti (OOP) usa oggetti per modellare entità reali.

Per gli sviluppatori che hanno familiarità con la programmazione strutturata, un confronto tra programmazione strutturata e programmazione orientata agli oggetti può aiutare a chiarire le differenze tra i due approcci. Inoltre, aumentando la comprensione dell'incapsulamento e del ciclo di vita della classe, è possibile sviluppare soluzioni sicure e affidabili.

Confrontare la programmazione Object-Oriented con la programmazione strutturata

La programmazione strutturata e la programmazione orientata agli oggetti (OOP) sono due approcci distinti allo sviluppo software, ognuno con un proprio set di principi e metodologie. La programmazione strutturata si basa su un approccio dall'alto verso il basso in cui il programma è suddiviso in funzioni o procedure più piccole e gestibili. Questo approccio evidenzia un flusso chiaro e logico del controllo usando cicli, condizionali e subroutine. La programmazione orientata agli oggetti organizza la progettazione software intorno agli oggetti che incapsulano sia i dati che il comportamento, promuovendo una struttura di codice più modulare e riutilizzabile. Mentre la programmazione strutturata è incentrata sulla sequenza di azioni da eseguire, la programmazione orientata agli oggetti evidenzia gli oggetti coinvolti nelle azioni.

È possibile usare esempi reali di progetti di costruzione come metafore per illustrare le differenze tra programmazione strutturata e programmazione orientata agli oggetti.

Esempio di programmazione Object-Oriented

Immagina programmazione orientata agli oggetti come progettazione e costruzione di una città. In questa metafora, ogni edificio rappresenta una classe, e le stanze e le strutture di ogni edificio rappresentano le proprietà e i metodi di tale classe. Proprio come una città è composta da vari edifici, ognuno dei quali serve uno scopo specifico (residenziale, commerciale, industriale), un programma OOP è composto da varie classi, ognuna progettata per gestire attività specifiche. Gli edifici (classi) vengono costruiti in base a progetti (definizioni di classi) e ogni edificio può avere più istanze (oggetti) che condividono la stessa struttura, ma possono avere stati diversi (dati).

In questa città, l'incapsulamento è come le mura di un edificio che protegge la sua struttura interna e consente solo l'accesso attraverso porte e finestre designate (metodi). L'incapsulamento garantisce che i lavori interni di un edificio (classe) siano nascosti dal mondo esterno e le interazioni con l'edificio siano controllate e sicure.

Questa metafora dell'edificio urbano evidenzia la natura modulare e riutilizzabile di OOP, in cui ogni classe (edificio) può essere sviluppata, testata e mantenuta in modo indipendente, ma lavorano tutti insieme per formare una città coesa e funzionale (programma). Proprio come una città ben pianificata consente una gestione e scalabilità efficienti, un programma OOP ben progettato promuove la gestibilità, la flessibilità e la scalabilità.

Esempio di programmazione strutturata

Si immagini una programmazione strutturata come creazione di un quilt. In questa metafora ogni pezzo di tessuto rappresenta una funzione o una procedura nel programma. Proprio come un quilt è costituito da molte patch singole cucite insieme, un programma strutturato è composto da varie funzioni progettate per eseguire attività specifiche. Ogni funzione è come una patch che può essere sviluppata, testata e mantenuta in modo indipendente. Quando si cuciscono queste patch in un ordine specifico, si crea un quilt completo, proprio come si combinano le funzioni per formare un programma completo.

Nella programmazione strutturata, lo stato attivo è sul flusso logico del controllo, molto simile a come un quilter pianifica il layout e la sequenza di patch per creare una progettazione coesiva. Il quilter garantisce che ogni patch si adatti perfettamente agli altri, mantenendo un modello chiaro e organizzato. Analogamente, un programmatore strutturato garantisce che ogni funzione si adatti perfettamente al programma complessivo, mantenendo un flusso chiaro e logico di controllo tramite l'uso di cicli, condizionali e subroutine.

Questa metafora di quilting evidenzia la natura modulare della programmazione strutturata, in cui ogni funzione (o patch) può essere riutilizzata e riorganizzata in base alle esigenze. Proprio come un quilter può sostituire o modificare singole patch senza interrompere l'intero quilt, un programmatore può aggiornare o perfezionare singole funzioni senza influire sull'intero programma. Questa modularità rende la programmazione strutturata un approccio efficace per la creazione di codice chiaro, gestibile e riutilizzabile. Tuttavia, man mano che il programma aumenta di dimensioni e complessità, la gestione delle interazioni tra le funzioni può diventare più complessa. Proprio come un quilt con troppe patch può diventare complicato e difficile da gestire, un programma strutturato con numerose funzioni e procedure può diventare complesso e difficile da gestire. Man mano che aumenta il numero di patch (funzioni), diventa più difficile tenere traccia del modo in cui interagiscono e interagiscono. Ciò comporta problemi come la duplicazione del codice, la difficoltà nel debug e la mancanza di coesione. Nelle applicazioni di grandi dimensioni, l'approccio lineare e dall'alto verso il basso della programmazione strutturata può comportare un web aggregato di funzioni interdipendenti, rendendo difficile comprendere e modificare la codebase. Questa complessità può ostacolare la scalabilità e la manutenibilità, influenzando infine la qualità e le prestazioni complessive del software.

Esaminare l'uso delle classi nella programmazione Object-Oriented

Le classi sono i blocchi predefiniti della programmazione orientata agli oggetti (OOP) e vengono usate per definire la struttura e il comportamento degli oggetti in un programma. Comprendere i vantaggi offerti dall'incapsulamento e dal ciclo di vita delle classi consente di comprendere il funzionamento della programmazione orientata agli oggetti.

Incapsulamento

L'incapsulamento è uno dei principi fondamentali della programmazione orientata agli oggetti (OOP). Si riferisce al raggruppamento di dati (campi) e metodi (comportamenti) che operano sui dati in una singola unità, in genere una classe. L'incapsulamento limita l'accesso diretto ad alcuni componenti di un oggetto, che può impedire la modifica accidentale dei dati.

L'incapsulamento offre i vantaggi seguenti:

Nascondi dati: l'incapsulamento consente di nascondere lo stato interno di un oggetto dall'esterno. Ciò significa che la rappresentazione interna di un oggetto può essere modificata senza influire sul codice esterno che usa l'oggetto . Ad esempio, usando campi privati e fornendo metodi getter e setter pubblici, è possibile controllare l'accesso e la modifica dei dati.

Manutenibilità migliorata: l'incapsulamento semplifica la gestione e la modifica del codice. Le modifiche apportate all'implementazione interna di una classe non influiscono sul codice che usa la classe, purché l'interfaccia pubblica rimanga invariata. Questa separazione dei problemi consente agli sviluppatori di concentrarsi su parti specifiche del codice senza preoccuparsi di effetti collaterali imprevisti.

Maggiore flessibilità: l'incapsulamento consente codice più flessibile e modulare. Definendo interfacce chiare, è possibile sostituire o aggiornare facilmente parti del codice senza influire sulle altre parti. Questa modularità semplifica il riutilizzo del codice e la compilazione di sistemi complessi da componenti più semplici.

Sicurezza avanzata: l'incapsulamento consente di proteggere l'integrità dei dati di un oggetto impedendo l'accesso e la modifica non autorizzati. Controllando l'accesso ai dati tramite metodi, è possibile applicare regole e vincoli sul modo in cui vengono usati i dati. Questa imposizione consente di evitare bug e assicurarsi che l'oggetto rimanga in uno stato valido.

Astrazione: l'incapsulamento supporta il concetto di astrazione esponendo solo i dettagli necessari di un oggetto al mondo esterno. Questo semplifica l'interfaccia e semplifica la comprensione e l'uso dell'oggetto. Gli utenti dell'oggetto non devono conoscere l'implementazione interna, riducendo la complessità del codice e migliorando la leggibilità.

Nota

L'incapsulamento consiste nel nascondere i membri dati non necessari agli utenti di una classe. I membri dati vengono incapsulati o nascosti usando la parola chiave della funzione di accesso private. L'accesso alle variabili di campo nascoste viene controllato usando proprietà e metodi. I membri dati nascosti non sono direttamente accessibili.


public class Person
{
    // Private fields
    private string firstName;
    private string lastName;
    private int age;

    // Public properties with getters and setters
    public string FirstName
    {
        get { return firstName; }
        set { firstName = value; }
    }

    public string LastName
    {
        get { return lastName; }
        set { lastName = value; }
    }

    public int Age
    {
        get { return age; }
        set
        {
            if (value >= 0)
            {
                age = value;
            }
            else
            {
                throw new ArgumentException("Age can't be negative");
            }
        }
    }

    // Public method
    public void Introduce()
    {
        Console.WriteLine($"Hi, I'm {FirstName} {LastName}, and I'm {Age} years old.");
    }
}

In questo esempio:

I campi firstName, lastNamee age sono private, ovvero non possono essere accessibili direttamente dall'esterno della classe .
Le proprietà pubbliche FirstName, LastNamee Age forniscono accesso controllato ai campi privati.
La proprietà Age include la logica di convalida per assicurarsi che l'età non possa essere impostata su un valore negativo.
Il metodo Introduce consente di interagire con i dati dell'oggetto senza esporre i dettagli di implementazione interni.

Ciclo di vita della classe

In un'applicazione C# il ciclo di vita di una classe prevede diverse fasi dalla relativa definizione alla sua eventuale distruzione. Il ciclo di vita di una classe include i passaggi seguenti:

Definizione classe: definire la classe con i relativi membri.
Compilazione: compilare la classe nel codice IL.
Caricamento: caricare l'assembly in memoria.
Creazione di un'istanza: creare un'istanza della classe .
Inizializzazione: inizializzare i campi e le proprietà dell'oggetto.
Utilizzo: usare l'oggetto nell'applicazione.
Garbage Collection: recuperare la memoria dell'oggetto quando non è più necessaria.
Distruzione: eseguire la logica di pulizia e rilasciare memoria.

Ecco un esempio che include come spiegazione di ogni passaggio del ciclo di vita di una classe:

Definizione di classe

Definizione: una classe viene definita nel codice sorgente con le relative proprietà, metodi e altri membri.

Per esempio:


public class Person
{
    // auto-implemented properties for name and age
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public int Age { get; set; }

    // method to introduce the person
    public void Introduce()
    {
        Console.WriteLine($"Hi, I'm {FirstName} {LastName}, and I'm {Age} years old.");
    }
}

Compilazione

Compilazione: il codice sorgente viene compilato in un linguaggio intermedio (IL) dal compilatore C#. Il codice IL viene archiviato in un assembly (file DLL o EXE).

Ad esempio: la classe Person viene compilata nel codice IL e inclusa nell'assembly.
Caricamento

Caricamento: quando l'applicazione viene eseguita, Common Language Runtime (CLR) carica l'assembly in memoria.

Ad esempio: l'assembly contenente la classe Person viene caricato in memoria da CLR.
Istanze

Creazione di istanze: viene creata un'istanza della classe usando la parola chiave new. Il costruttore della classe viene chiamato per inizializzare l'oggetto.

Per esempio:
```
Person person1 = new Person { FirstName = "Tim", LastName = "Shao", Age = 25 };
```
Inizializzazione

Inizializzazione: il costruttore inizializza i campi e le proprietà dell'oggetto. Viene eseguita qualsiasi logica di inizializzazione definita nel costruttore.

Esempio: l'oggetto Personperson1 viene inizializzato con i valori specificati per FirstName, LastNamee Age.
Uso

Utilizzo: l'oggetto viene usato nell'applicazione. I metodi e le proprietà dell'oggetto sono accessibili e modificati in base alle esigenze.

Per esempio:
```
person1.Introduce();
```
Raccolta dei rifiuti

Garbage Collection: quando l'oggetto non è più necessario e non vi sono riferimenti, il Garbage Collector (GC) recupera la memoria usata dall'oggetto . Il distruttore (finalizzatore) viene chiamato se definito.

Esempio: se person1 non viene più fatto riferimento in un punto qualsiasi del codice, il GC alla fine recupererà la memoria.
Distruzione

Distruzione: la memoria dell'oggetto viene rilasciata e viene eseguita qualsiasi logica di pulizia definita nel distruttore (il finalizzatore se specificato).

Esempio: l'oggetto Personperson1 viene eliminato definitivamente e la relativa memoria viene recuperata dal GC.

Commenti e suggerimenti

Questa pagina è stata utile?