Encapsulamento e modificadores de acesso

Boas-vindas à próxima lição! Nesta lição, você aprenderá sobre encapsulamento, um conceito essencial da POO, e como os modificadores de acesso controlam a visibilidade dos membros de uma classe em C#. Vamos começar!

O que é encapsulamento?

Encapsulamento é o processo de agrupar dados (campos) e comportamento (métodos) em uma única unidade (classe), restringindo o acesso direto a alguns componentes. Isso é feito para proteger a integridade dos dados e impor regras para acessá-los.

Ponto principal: O encapsulamento permite ocultar detalhes de implementação e expor somente a funcionalidade necessária.

Por que o encapsulamento é importante?

O encapsulamento oferece vários benefícios:

• Proteção de dados: Impede o acesso não autorizado ou inválido aos campos da classe.
• Manutenibilidade do código: Alterações na implementação interna não afetam o código externo.
• Maior modularidade: Mantém o código organizado e fácil de entender.

Exemplo: Uma classe com campos privados e métodos públicos para gerenciar esses campos demonstra o encapsulamento.

Entendendo os modificadores de acesso

Os modificadores de acesso em C# definem o escopo de acessibilidade dos membros de uma classe:

• público: Pode ser acessado de qualquer lugar.
• privado: Pode ser acessado somente dentro da mesma classe.
• protegido: Pode ser acessado dentro da mesma classe e de classes derivadas.
• interno: Pode ser acessado dentro do mesmo assembly.
• protegido interno: Pode ser acessado dentro do mesmo assembly ou de classes derivadas.

Ponto principal: Use modificadores de acesso para aplicar o encapsulamento.

Exemplo: encapsulamento com campos privados

Veja um exemplo de encapsulamento usando campos privados e métodos públicos:

Ponto principal: Use campos privados para restringir o acesso direto e métodos públicos para expor funcionalidades controladas.

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

Encapsulamento com propriedades

As propriedades oferecem uma maneira mais simples de encapsular campos, permitindo incluir lógica de validação. Exemplo:

Dica: Use propriedades em vez de métodos básicos de leitura e atribuição para melhorar a legibilidade.

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

Desafio prático

Crie uma classe chamada Student com os campos privados Name e Age. Use propriedades para encapsular esses campos e garantir que a idade seja sempre positiva. Exemplo:

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

Boas práticas para encapsulamento

Veja algumas boas práticas:

• Sempre use campos privados para dados sensíveis.
• Use propriedades ou métodos para validar e controlar o acesso aos campos.
• Combine o encapsulamento com modificadores de acesso para proteger seu código.

Dica: O encapsulamento ajuda você a criar aplicações seguras e fáceis de manter.

Muito bem!

Parabéns! Você aprendeu a usar encapsulamento e modificadores de acesso para proteger e organizar seus dados. Na próxima lição, vamos explorar a herança e aprender a reutilizar código com eficiência. Vamos continuar programando!