Incapsulamento e modificatori di accesso

Benvenuto nella prossima lezione! In questa lezione imparerà a conoscere l'incapsulamento, un concetto fondamentale della programmazione orientata agli oggetti, e come i modificatori di accesso controllano la visibilità dei membri di una classe in C#. Iniziamo!

Che cos'è l'incapsulamento?

L'incapsulamento è il processo di raggruppamento di dati (campi) e comportamento (metodi) in una singola unità (classe), limitando al contempo l'accesso diretto ad alcuni componenti. Questo protegge l'integrità dei dati e impone regole per accedervi.

Punto chiave: l'incapsulamento consente di nascondere i dettagli di implementazione ed esporre solo le funzionalità necessarie.

Perché l'incapsulamento è importante?

L'incapsulamento offre diversi vantaggi:

• Protezione dei dati: impedisce l'accesso non autorizzato o non valido ai campi della classe.
• Manutenibilità del codice: le modifiche all'implementazione interna non influiscono sul codice esterno.
• Maggiore modularità: mantiene il codice organizzato e facile da comprendere.

Esempio: una classe con campi privati e metodi pubblici per gestire tali campi dimostra l'incapsulamento.

Comprendere i modificatori di accesso

I modificatori di accesso in C# definiscono l'ambito di accessibilità dei membri di una classe:

• public: accessibile da qualsiasi punto.
• private: accessibile solo all'interno della stessa classe.
• protected: accessibile all'interno della stessa classe e delle classi derivate.
• internal: accessibile all'interno dello stesso assembly.
• protected internal: accessibile all'interno dello stesso assembly o nelle classi derivate.

Punto chiave: utilizzi i modificatori di accesso per applicare l'incapsulamento.

Esempio: incapsulamento con campi privati

Ecco un esempio di incapsulamento con campi privati e metodi pubblici:

Punto chiave: utilizzi campi privati per limitare l'accesso diretto e metodi pubblici per esporre funzionalità controllate.

using System;

class BankAccount {
    private decimal balance; // Private field

    public void Deposit(decimal amount) {
        if (amount > 0) {
            balance += amount;
        } else {
            Console.WriteLine("Deposit amount must be positive.");
        }
    }

    public decimal GetBalance() {
        return balance; // Access balance through a method
    }
}

class Program {
    static void Main() {
        BankAccount account = new BankAccount();
        account.Deposit(100.50m); // Deposit money
        Console.WriteLine("Balance: $" + account.GetBalance()); // Get balance
    }
}

Incapsulamento con proprietà

Le proprietà offrono un modo più chiaro per incapsulare i campi, consentendo al contempo di aggiungere una logica di convalida. Ecco un esempio:

Suggerimento: utilizzi le proprietà invece di getter e setter espliciti per migliorare la leggibilità.

using System;

class BankAccount {
    private decimal balance; // Private field

    public decimal Balance { // Property with validation
        get { return balance; }
        set {
            if (value >= 0) {
                balance = value;
            } else {
                Console.WriteLine("Balance cannot be negative.");
            }
        }
    }
}

class Program {
    static void Main() {
        BankAccount account = new BankAccount();
        account.Balance = 200; // Set balance
        Console.WriteLine("Balance: $" + account.Balance); // Get balance
    }
}

Esercizio pratico

Crei una classe chiamata Student con i campi privati Name e Age. Utilizzi le proprietà per incapsulare questi campi e garantire che l'età sia sempre positiva. Ecco un esempio:

using System;

class Student {
    private string name;
    private int age;

    public string Name {
        get { return name; }
        set { name = value; }
    }

    public int Age {
        get { return age; }
        set {
            if (value > 0) {
                age = value;
            } else {
                Console.WriteLine("Age must be positive.");
            }
        }
    }
}

class Program {
    static void Main() {
        Student student = new Student();
        student.Name = "Alice";
        student.Age = 20;

        Console.WriteLine("Name: " + student.Name);
        Console.WriteLine("Age: " + student.Age);
    }
}

Buone pratiche per l'incapsulamento

Ecco alcune buone pratiche:

• Utilizzi sempre campi privati per i dati sensibili.
• Utilizzi proprietà o metodi per convalidare e controllare l'accesso ai campi.
• Combini l'incapsulamento con i modificatori di accesso per proteggere il codice.

Suggerimento: l'incapsulamento aiuta a creare applicazioni sicure e facili da mantenere.

Ottimo lavoro!

Congratulazioni! Ha imparato a utilizzare l'incapsulamento e i modificatori di accesso per proteggere e organizzare i dati. Nella prossima lezione esploreremo l'ereditarietà e impareremo a riutilizzare il codice in modo efficiente. Continuiamo a programmare!