Enkapsulacja i modyfikatory dostępu

Witamy w kolejnej lekcji! W tej lekcji poznają Państwo enkapsulację, czyli podstawowe pojęcie programowania obiektowego, oraz dowiedzą się, jak modyfikatory dostępu kontrolują widoczność składowych klasy w języku C#. Zaczynajmy!

Czym jest enkapsulacja?

Enkapsulacja polega na łączeniu danych (pól) i zachowania (metod) w jednej jednostce (klasie) przy jednoczesnym ograniczeniu bezpośredniego dostępu do niektórych składników. Służy to ochronie integralności danych i wymuszaniu określonych zasad dostępu do nich.

Najważniejsze: Enkapsulacja umożliwia ukrycie szczegółów implementacji i udostępnienie tylko niezbędnych funkcji.

Dlaczego enkapsulacja jest ważna?

Enkapsulacja zapewnia wiele korzyści:

• Ochrona danych: Zapobiega nieuprawnionemu lub nieprawidłowemu dostępowi do pól klasy.
• Łatwiejsze utrzymanie kodu: Zmiany w implementacji wewnętrznej nie wpływają na kod zewnętrzny.
• Lepsza modularność: Pomaga zachować uporządkowanie i czytelność kodu.

Przykład: Klasa z prywatnymi polami i publicznymi metodami do zarządzania tymi polami jest przykładem enkapsulacji.

Poznawanie modyfikatorów dostępu

Modyfikatory dostępu w języku C# określają zakres dostępności składowych klasy:

• public: Dostępny z dowolnego miejsca.
• private: Dostępny tylko w obrębie tej samej klasy.
• protected: Dostępny w obrębie tej samej klasy i klas pochodnych.
• internal: Dostępny w obrębie tego samego zestawu.
• protected internal: Dostępny w obrębie tego samego zestawu lub dla klas pochodnych.

Najważniejsze: Modyfikatory dostępu służą do wymuszania enkapsulacji.

Przykład: enkapsulacja z użyciem pól prywatnych

Poniżej przedstawiono przykład enkapsulacji z użyciem pól prywatnych i metod publicznych:

Najważniejsze: Pól prywatnych należy używać do ograniczania bezpośredniego dostępu, a metod publicznych — do udostępniania kontrolowanej funkcjonalności.

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
    }
}

Enkapsulacja z użyciem właściwości

Właściwości zapewniają czytelniejszy sposób enkapsulowania pól przy jednoczesnym umożliwieniu stosowania logiki sprawdzającej poprawność danych. Przykład:

Wskazówka: Dla lepszej czytelności warto używać właściwości zamiast bezpośrednich getterów i setterów.

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
    }
}

Zadanie praktyczne

Proszę utworzyć klasę o nazwie Student z prywatnymi polami Name i Age. Proszę użyć właściwości do enkapsulowania tych pól i zapewnić, że wiek będzie zawsze dodatni. Przykład:

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);
    }
}

Dobre praktyki dotyczące enkapsulacji

Oto kilka dobrych praktyk:

• Dla danych wrażliwych zawsze należy używać pól prywatnych.
• Do sprawdzania poprawności danych i kontrolowania dostępu do pól należy używać właściwości lub metod.
• Warto łączyć enkapsulację z modyfikatorami dostępu, aby chronić kod.

Wskazówka: Enkapsulacja pomaga tworzyć bezpieczne i łatwe w utrzymaniu aplikacje.

Świetna robota!

Gratulacje! Poznali Państwo sposób używania enkapsulacji i modyfikatorów dostępu do ochrony i organizowania danych. W następnej lekcji omówimy dziedziczenie i dowiemy się, jak efektywnie ponownie używać kodu. Programujmy dalej!