Examinar la estructura de programas orientados a objetos

11 minutos

La programación orientada a objetos (OOP) usa objetos para modelar entidades reales.

Para los desarrolladores que están familiarizados con la programación estructurada, una comparación entre la programación estructurada y la programación orientada a objetos puede ayudar a aclarar las diferencias entre los dos enfoques. Además, aumentar la comprensión de la encapsulación y el ciclo de vida de las clases puede ayudarle a desarrollar soluciones seguras y sólidas.

Comparación de Object-Oriented Programación con programación estructurada

La programación estructurada y la programación orientada a objetos (OOP) son dos enfoques distintos para el desarrollo de software, cada uno con su propio conjunto de principios y metodologías. La programación estructurada se basa en un enfoque de arriba abajo en el que el programa se divide en funciones o procedimientos más pequeños y administrables. Este enfoque hace hincapié en un flujo de control claro y lógico mediante bucles, condicionales y subrutinas. La programación orientada a objetos organiza el diseño de software en torno a objetos que encapsulan datos y comportamientos, lo que promueve una estructura de código más modular y reutilizable. Aunque la programación estructurada se centra en la secuencia de acciones que se van a realizar, la programación orientada a objetos resalta los objetos implicados en las acciones.

Podemos usar ejemplos reales de proyectos de construcción como metáforas para ilustrar las diferencias entre la programación estructurada y la programación orientada a objetos.

Ejemplo de programación de Object-Oriented

Imagine la programación orientada a objetos como diseño y construcción de una ciudad. En esta metáfora, cada edificio representa una clase, y las salas y instalaciones de cada edificio representan las propiedades y métodos de esa clase. Al igual que una ciudad se compone de varios edificios, cada uno de los cuales sirve un propósito específico (residencial, comercial, industrial), un programa de OOP se compone de diversas clases, cada uno diseñado para manejar tareas específicas. Los edificios (clases) se construyen en función de planos técnicos (definiciones de clase) y cada edificio puede tener varias instancias (objetos) que comparten la misma estructura, pero pueden tener estados diferentes (datos).

En esta ciudad, la encapsulación es como las paredes de un edificio que protegen su estructura interna y solo permiten el acceso a través de puertas y ventanas designadas (métodos). La encapsulación garantiza que los trabajos internos de un edificio (clase) están ocultos del mundo exterior y las interacciones con el edificio son controladas y seguras.

Esta metáfora de construcción urbana destaca la naturaleza modular y reutilizable de la OOP, donde cada clase (edificio) se puede desarrollar, probar y mantener de forma independiente, pero todos trabajan juntos para formar una ciudad funcional y cohesiva (programa). Al igual que una ciudad bien planeada permite una gestión y escalabilidad eficientes, un programa de OOP bien diseñado promueve la capacidad de mantenimiento, la flexibilidad y la escalabilidad.

Ejemplo de programación estructurada

Imagine la programación estructurada como una quilt. En esta metáfora, cada pieza de tejido representa una función o procedimiento en el programa. Al igual que una quilt se compone de muchas revisiones individuales cosidas juntas, un programa estructurado se compone de varias funciones diseñadas para realizar tareas específicas. Cada función es como una revisión que se puede desarrollar, probar y mantener de forma independiente. Al coser estas revisiones en un orden específico, se crea una edredón completa, al igual que combina funciones para formar un programa completo.

En la programación estructurada, el enfoque se centra en el flujo lógico de control, al igual que el modo en que un quilter planea el diseño y la secuencia de revisiones para crear un diseño cohesivo. El quilter garantiza que cada parche se ajuste perfectamente a los demás, manteniendo un patrón claro y organizado. Del mismo modo, un programador estructurado garantiza que cada función se ajuste perfectamente al programa general, manteniendo un flujo de control claro y lógico a través del uso de bucles, condicionales y subrutinas.

Esta metáfora de quilting resalta la naturaleza modular de la programación estructurada, donde cada función (o revisión) se puede reutilizar y reorganizar según sea necesario. Al igual que un quilter puede reemplazar o modificar revisiones individuales sin interrumpir toda la quilt, un programador puede actualizar o refinar funciones individuales sin afectar a todo el programa. Esta modularidad hace que la programación estructurada sea un enfoque eficaz para crear código claro, fácil de mantener y reutilizable. Sin embargo, a medida que el programa crece en tamaño y complejidad, la administración de las interacciones entre las funciones puede resultar más difícil. Al igual que una edredón con demasiadas revisiones puede volverse inconfundible y difícil de administrar, un programa estructurado con numerosas funciones y procedimientos puede resultar complicado y difícil de mantener. A medida que aumenta el número de revisiones (funciones), resulta más difícil realizar un seguimiento de cómo encajan e interactúan. Esto conduce a problemas como la duplicación de código, la dificultad en la depuración y la falta de cohesión. En aplicaciones grandes, el enfoque lineal y descendente de la programación estructurada puede dar lugar a una web enredada de funciones interdependientes, lo que dificulta la comprensión y modificación del código base. Esta complejidad puede dificultar la escalabilidad y el mantenimiento, lo que en última instancia afecta a la calidad y el rendimiento generales del software.

Examen del uso de clases en Object-Oriented Programación

Las clases son los bloques de creación de programación orientada a objetos (OOP) y se usan para definir la estructura y el comportamiento de los objetos en un programa. Comprender las ventajas proporcionadas por la encapsulación y el ciclo de vida de las clases le ayuda a comprender cómo funciona la programación orientada a objetos.

Encapsulación

La encapsulación es uno de los principios fundamentales de la programación orientada a objetos (OOP). Hace referencia a la agrupación de datos (campos) y métodos (comportamientos) que operan en los datos en una sola unidad, normalmente una clase. La encapsulación restringe el acceso directo a algunos de los componentes de un objeto, lo que puede impedir la modificación accidental de los datos.

La encapsulación proporciona las siguientes ventajas:

Ocultación de datos: la encapsulación permite ocultar el estado interno de un objeto desde el exterior. Esto significa que la representación interna de un objeto se puede cambiar sin afectar al código externo que usa el objeto . Por ejemplo, mediante el uso de campos privados y el suministro de métodos de captador y establecedor públicos, puede controlar cómo se accede y modifican los datos.

Mejora del mantenimiento: la encapsulación facilita el mantenimiento y modificación del código. Los cambios en la implementación interna de una clase no afectan al código que usa la clase, siempre y cuando la interfaz pública siga siendo la misma. Esta separación de preocupaciones permite a los desarrolladores centrarse en partes específicas del código sin preocuparse por los efectos secundarios no deseados.

Mayor flexibilidad: la encapsulación permite código más flexible y modular. Al definir interfaces claras, puede reemplazar o actualizar fácilmente partes del código sin afectar a otras partes. Esta modularidad facilita la reutilización del código y la creación de sistemas complejos a partir de componentes más sencillos.

Seguridad mejorada: la encapsulación ayuda a proteger la integridad de los datos de un objeto evitando el acceso y la modificación no autorizados. Al controlar el acceso a los datos a través de métodos, puede aplicar reglas y restricciones sobre cómo se usan los datos. Esta aplicación ayuda a evitar errores y a garantizar que el objeto permanece en un estado válido.

Abstracción: la encapsulación admite el concepto de abstracción al exponer solo los detalles necesarios de un objeto al mundo exterior. Esto simplifica la interfaz y facilita la comprensión y el uso del objeto. Los usuarios del objeto no necesitan conocer la implementación interna, lo que reduce la complejidad del código y mejora la legibilidad.

Nota

La encapsulación consiste en ocultar los miembros de datos que los usuarios de una clase no necesitan. Los miembros de datos se encapsulan o ocultan mediante la palabra clave de descriptor de acceso private. El acceso a variables de campo ocultas se controla mediante propiedades y métodos. Los miembros de datos ocultos no son accesibles directamente.


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

En este ejemplo:

Los campos firstName, lastNamey age son private, lo que significa que no se puede tener acceso directamente desde fuera de la clase .
Las propiedades públicas FirstName, LastNamey Age proporcionan acceso controlado a los campos privados.
La propiedad Age incluye lógica de validación para asegurarse de que la antigüedad no se puede establecer en un valor negativo.
El método Introduce proporciona una manera de interactuar con los datos del objeto sin exponer los detalles de implementación internos.

Ciclo de vida de la clase

En una aplicación de C#, el ciclo de vida de una clase implica varias fases de su definición a su eventual destrucción. El ciclo de vida de una clase incluye los pasos siguientes:

Definición de clase: defina la clase con sus miembros.
Compilación: compile la clase en código IL.
Carga: cargue el ensamblado en la memoria.
Creación de instancias: cree una instancia de la clase .
Inicialización: inicialice los campos y propiedades del objeto.
Uso: use el objeto en la aplicación.
Recolección de elementos no utilizados: recupere la memoria del objeto cuando ya no sea necesaria.
Destrucción: ejecute la lógica de limpieza y libere la memoria.

Este es un ejemplo que incluye como explicación de cada paso del ciclo de vida de una clase:

Definición de clase

Definición: una clase se define en el código fuente con sus propiedades, métodos y otros miembros.

Por ejemplo:


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

Compilación

Compilación: el compilador de C# compila el código fuente en un lenguaje intermedio (IL). El código IL se almacena en un ensamblado (archivo DLL o EXE).

Por ejemplo: la clase Person se compila en código IL y se incluye en el ensamblado.
Carga

Carga: cuando se ejecuta la aplicación, Common Language Runtime (CLR) carga el ensamblado en memoria.

Por ejemplo: CLR carga en memoria el ensamblado que contiene la clase Person.
Instanciación

Creación de instancias: se crea una instancia de la clase mediante la palabra clave new. Se llama al constructor de la clase para inicializar el objeto .

Por ejemplo:
```
Person person1 = new Person { FirstName = "Tim", LastName = "Shao", Age = 25 };
```
Inicialización

Inicialización: el constructor inicializa los campos y propiedades del objeto. Se ejecuta cualquier lógica de inicialización definida en el constructor.

Ejemplo: el objeto Personperson1 se inicializa con los valores especificados para FirstName, LastNamey Age.
Uso

Uso: el objeto se usa en la aplicación. Se accede a los métodos y propiedades del objeto y se modifican según sea necesario.

Por ejemplo:
```
person1.Introduce();
```
Recolección

Recolección de elementos no utilizados: cuando el objeto ya no es necesario y no hay referencias a él, el recolector de elementos no utilizados (GC) reclama la memoria usada por el objeto . Se llama al destructor (finalizador) si se define.

Ejemplo: Si ya no se hace referencia a person1 en ningún lugar del código, el GC finalmente reclamará su memoria.
Destrucción

Destrucción: se libera la memoria del objeto y se ejecuta cualquier lógica de limpieza definida en el destructor (el finalizador si se especifica).

Ejemplo: el objeto Personperson1 se destruye y la gc reclama su memoria.

Comentarios

¿Le ha resultado útil esta página?