El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Encapsulamiento

Siguiente ►
►

El encapsulamiento es uno de los cuatro pilares fundamentales de la Programación Orientada a Objetos (POO), junto con la herencia, el polimorfismo y la abstracción. Este concepto se refiere a la práctica de restringir el acceso directo a algunos de los componentes de un objeto y solo permitir su modificación a través de métodos definidos.

Conceptos Clave

  1. Encapsulamiento: Proceso de ocultar los detalles internos de un objeto y exponer solo lo necesario.
  2. Modificadores de Acceso: Palabras clave que controlan el acceso a los miembros de una clase.
  3. Propiedades: Métodos especiales que permiten acceder y modificar los campos privados de una clase.

Modificadores de Acceso

En C#, los modificadores de acceso más comunes son:

  • public: El miembro es accesible desde cualquier parte del código.
  • private: El miembro es accesible solo dentro de la misma clase.
  • protected: El miembro es accesible dentro de la misma clase y en clases derivadas.
  • internal: El miembro es accesible solo dentro del mismo ensamblado.
  • protected internal: El miembro es accesible dentro del mismo ensamblado y en clases derivadas.

Ejemplo de Modificadores de Acceso

public class Persona
{
    // Campo privado
    private string nombre;

    // Campo público
    public int edad;

    // Campo protegido
    protected string direccion;

    // Campo interno
    internal string telefono;

    // Campo protegido interno
    protected internal string email;
}

Propiedades

Las propiedades en C# permiten controlar el acceso a los campos privados de una clase. Se utilizan para encapsular datos y proporcionar métodos de acceso (get) y modificación (set).

Ejemplo de Propiedades

public class Persona
{
    // Campo privado
    private string nombre;

    // Propiedad pública para acceder al campo privado
    public string Nombre
    {
        get { return nombre; }
        set { nombre = value; }
    }

    // Propiedad auto-implementada
    public int Edad { get; set; }
}

En este ejemplo, la propiedad Nombre permite acceder y modificar el campo privado nombre. La propiedad Edad es una propiedad auto-implementada, lo que significa que C# genera automáticamente un campo privado para almacenar el valor.

Ejemplo Completo

A continuación, se muestra un ejemplo completo que demuestra el uso del encapsulamiento en una clase Persona.

public class Persona
{
    // Campos privados
    private string nombre;
    private int edad;

    // Propiedad pública para acceder al campo privado 'nombre'
    public string Nombre
    {
        get { return nombre; }
        set { nombre = value; }
    }

    // Propiedad pública para acceder al campo privado 'edad'
    public int Edad
    {
        get { return edad; }
        set
        {
            if (value >= 0)
            {
                edad = value;
            }
            else
            {
                throw new ArgumentException("La edad no puede ser negativa");
            }
        }
    }

    // Método público
    public void MostrarInformacion()
    {
        Console.WriteLine($"Nombre: {Nombre}, Edad: {Edad}");
    }
}

class Program
{
    static void Main(string[] args)
    {
        Persona persona = new Persona();
        persona.Nombre = "Juan";
        persona.Edad = 30;
        persona.MostrarInformacion();
    }
}

Explicación del Código

  1. Campos Privados: nombre y edad son campos privados que no pueden ser accedidos directamente desde fuera de la clase.
  2. Propiedades: Nombre y Edad son propiedades públicas que permiten acceder y modificar los campos privados.
  3. Validación: La propiedad Edad incluye una validación para asegurarse de que la edad no sea negativa.
  4. Método Público: MostrarInformacion es un método público que imprime la información de la persona.

Ejercicio Práctico

Ejercicio

Crea una clase Coche que tenga los siguientes campos privados: marca, modelo y año. Implementa propiedades públicas para acceder y modificar estos campos. Asegúrate de que el año no pueda ser negativo.

Solución

public class Coche
{
    // Campos privados
    private string marca;
    private string modelo;
    private int año;

    // Propiedad pública para acceder al campo privado 'marca'
    public string Marca
    {
        get { return marca; }
        set { marca = value; }
    }

    // Propiedad pública para acceder al campo privado 'modelo'
    public string Modelo
    {
        get { return modelo; }
        set { modelo = value; }
    }

    // Propiedad pública para acceder al campo privado 'año'
    public int Año
    {
        get { return año; }
        set
        {
            if (value >= 0)
            {
                año = value;
            }
            else
            {
                throw new ArgumentException("El año no puede ser negativo");
            }
        }
    }

    // Método público
    public void MostrarInformacion()
    {
        Console.WriteLine($"Marca: {Marca}, Modelo: {Modelo}, Año: {Año}");
    }
}

class Program
{
    static void Main(string[] args)
    {
        Coche coche = new Coche();
        coche.Marca = "Toyota";
        coche.Modelo = "Corolla";
        coche.Año = 2020;
        coche.MostrarInformacion();
    }
}

Explicación del Ejercicio

  1. Campos Privados: marca, modelo y año son campos privados.
  2. Propiedades: Marca, Modelo y Año son propiedades públicas que permiten acceder y modificar los campos privados.
  3. Validación: La propiedad Año incluye una validación para asegurarse de que el año no sea negativo.
  4. Método Público: MostrarInformacion es un método público que imprime la información del coche.

Conclusión

El encapsulamiento es una práctica esencial en la programación orientada a objetos que ayuda a proteger los datos y a mantener la integridad de los objetos. Al utilizar modificadores de acceso y propiedades, puedes controlar cómo se accede y modifica la información dentro de tus clases, lo que resulta en un código más seguro y mantenible.

En el próximo tema, exploraremos la abstracción, otro pilar fundamental de la POO, que nos permitirá simplificar la complejidad del código al enfocarnos en los aspectos esenciales de los objetos.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados