No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Abstracción

15/19
Recursos

¿Qué es la abstracción en la programación orientada a objetos?

La abstracción es un concepto poderoso en la programación orientada a objetos (POO) que permite crear componentes más genéricos y reutilizables. Al no incluir detalles específicos desde el inicio, podemos aplicar abstracción para beneficiar tanto el diseño como la reutilización del código. Este principio se combina bien con otros elementos avanzados de la programación como los patrones de diseño.

¿Cómo implementar abstracción y herencia en C#?

Para integrar la abstracción en nuestro código, podemos usar clases y métodos abstractos en C#. Aquí presentamos un ejemplo ilustrativo:

// Definición de una clase abstracta con un método abstracto
public abstract class Heroe {
    public abstract string SalvarElMundo();
}

Este método SalvarElMundo() es abstracto y no contiene detalles de implementación. La clase Heroe debe ser abstracta, dado que una clase no abstracta no puede tener métodos abstractos.

¿Qué ocurre al heredar clases abstractas?

Al heredar de una clase abstracta, como es el caso de nuestra clase SuperHeroe que hereda Heroe, es obligatorio implementar el método abstracto en la clase hija. A continuación, el ejemplo de implementación:

public class SuperHeroe : Heroe {
    public override string SalvarElMundo() {
        return $"{NombreIdentidadSecreta} ha salvado el mundo";
    }
}

Visual Studio ayuda a identificar este tipo de errores y exige que se añada el override para implementar el cuerpo del método abstracto.

¿Cómo podemos utilizar tanto métodos abstractos como no abstractos?

Además de métodos abstractos, las clases abstractas también pueden contener métodos "normales" que no necesitan ser implementados en las clases hijas. Aquí un ejemplo que muestra ambos tipos de métodos en una clase:

public abstract class Heroe {
    // Método abstracto
    public abstract string SalvarElMundo();
    
    // Método no abstracto
    public string SalvarLaTierra() {
        return $"{Nombre} ha salvado la tierra";
    }
}

La clase SuperHeroe puede heredar tanto métodos abstractos como no abstractos sin mostrar errores al no tener que sobrescribir el método no abstracto:

public class SuperHeroe : Heroe {
    public override string SalvarElMundo() {
        return $"{NombreIdentidadSecreta} ha salvado el mundo";
    }
}

¿Cómo aprovechar las propiedades abstractas?

Similar a los métodos, se pueden declarar propiedades abstractas obligando a las clases hijas a definirlas. Esto se hace de la siguiente manera:

public abstract class Heroe {
    public abstract string Nombre { get; set; }
}

En la clase SuperHeroe, la implementación de propiedades abstractas también es obligatoria:

public class SuperHeroe : Heroe {
    // Implementación de la propiedad abstracta
    public override string Nombre { get; set; } = "Superman";
    
    public override string SalvarElMundo() {
        return $"{NombreIdentidadSecreta} ha salvado el mundo";
    }
}

La abstracción es esencial para permitir la evolución de nuestros sistemas sin refactorizaciones masivas, maximizando la reutilización de código y la cohesión. Estos principios no solo mejoran el diseño del software sino que impulsan la robustez y el mantenimiento a largo plazo. Sigamos explorando estos conceptos en nuestro camino para dominar la programación orientada a objetos.

Aportes 7

Preguntas 2

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Siempre que tenemos un método o una propiedad abstracta, la clase que los contenga debe ser abstracta.
De igual manera, debemos hacer el override en la clase que está heredando de esta clase abstracta en dicha propiedad o método

Las clases abstractas obligan a las clases que la heredan a implementar sus métodos abstractos:

  • Cuando en una clase abstracta se crean susmétodos, estos no pueden contener un cuerpo de dicho método.
  • Cuando se hereda de una clase abstracta que contiene métodos o propiedades abstractas por obligación la clase que lo hereda tiene que implementarla con la palabra reservada override y crear el cuerpo de los métodos.
## Clases abstractas en C#: **Definición:** Una clase abstracta define una plantilla para otras clases, pero no se pueden crear objetos de ella directamente. **Características:** * Contiene al menos un método abstracto (sin implementación). * Las clases que heredan de una clase abstracta deben implementar sus métodos abstractos. * No se pueden crear instancias de una clase abstracta. **Ejemplo:** ```js public abstract class Animal { public abstract void Hablar(); } public class Perro : Animal { public override void Hablar() { Console.WriteLine("Guau!"); } } public class Gato : Animal { public override void Hablar() { Console.WriteLine("Miau!"); } } ```**En este ejemplo:** * `Animal` es una clase abstracta con un método abstracto `Hablar`. * `Perro` y `Gato` heredan de `Animal` y implementan el método `Hablar`. **Uso:** * Las clases abstractas son útiles para definir una interfaz común para clases relacionadas. * Permiten la reutilización de código y la creación de jerarquías de clases.
**CONCEPTO DE ABSTRACCIÓN:**  Este concepto nos permite crear componentes más genéricos sin detalles específicos, lo que facilita la reutilización del código y la aplicación de patrones de diseño avanzados. **CLASE ABSTRACTA:** En nuestro proyecto de superhéroes en Visual Studio, tenemos las clases Superheroe y Antiheroe. Para aplicar la abstracción, crearemos una nueva clase que combina la abstracción con la herencia: la clase abstracta Héroe. Esta clase será padre de Superhéroe, ya que un superhéroe también puede ser considerado un héroe. Definiremos en esta clase un método abstracto llamado SalvarElMundo(), ya que todos los héroes, sin importar si tienen superpoderes, realizan esta acción sin dudarlo. Para indicar que el método SalvarElMundo() es abstracto, lo declararemos con la palabra clave abstract. Los métodos abstractos no tienen definida la implementación. **IMPLEMENTACIÓN DEL MÉTODO:** Al heredar la clase Superheroe de la clase Heroe, será necesario implementar el método abstracto SalvarElMundo() utilizando la palabra clave override. **PROPIEDADES ABSTRACTAS:** Crearemos una propiedad abstracta llamada Nombre en la clase Héroe para representar el nombre del héroe. Al heredar esta propiedad en la clase Superhéroe, se deberá implementar utilizando la palabra clave override. **CREACIÓN DE MÉTODOS NO ABSTRACTOS:** Además de los métodos abstractos, también podemos incluir métodos no abstractos en la clase Héroe, como SalvarLaTierra(). Estos métodos pueden ser utilizados directamente en las clases hijas sin necesidad de implementarlos nuevamente.
La abstracción en programación orientada a objetos (POO) es el proceso de ocultar los detalles complejos y mostrar solo las características esenciales de un objeto. Permite crear componentes más generales y reutilizables. Por ejemplo, al definir una clase abstracta, se especifican métodos sin implementar su lógica, obligando a las clases derivadas a proporcionar su propia implementación. Esto mejora la modularidad y la mantenibilidad del código, facilitando la aplicación de patrones de diseño.
![](https://i.ibb.co/74FHsPT/ccc.png)
Yo estoy haciendo mis ejercicios simulando un sistema de registro de estudiantes y profesores en una escuela, asi que en lugar de crear la clase abstracta Heroe, he creado la clase abstracta Person. Esta es mi clase: `using System;` `using System.Collections.Generic;` `using System.Linq;` `using System.Text;` `using System.Threading.Tasks;` `namespace SchoolSystemProject.Models` `{` ` abstract class Person` ` {` ` private string _FirstName;` ` private string _LastName;` ` public int Id { get; set; }` ` public string FirstName` ` {` ` get { return _FirstName; }` ` set { _FirstName = value.Trim(); } ` ` }` ` public string LastName` ` {` ` get { return _LastName; }` ` set { _LastName = value.Trim(); }` ` }` ` public string FullName` ` {` ` get { return $"{FirstName} {LastName}"; }` ` }` ` public int Age { get; set; }` ` public string Address { get; set; }` ` public bool HasMedicalCondition { get; set; }` ` public List<Subject> Subjects { get; set; } = new List<Subject>(); //initializing List so every time that an object is created, the list will be empty from the begginig.` ` //public string[] Subjects; -- - This was used at first cause I didn't have class Subject set neither a way to call a list. Afther Subject class is created I must set the attribute like above.` ` ` ` public abstract void DisplayRole();` ` public void PrintSubjects()` ` {` ` foreach (var item in Subjects)` ` {` ` Console.WriteLine($"{FullName} is enrolled on: {item.SubjectName}");` ` ` ` //Console.WriteLine($"{FirstName} {LastName} is enrolled on: {item.SubjectName}"); -- excluded because FullName has been created and this is not needed now.` ` }` ` }` ` }` `}`