Clases abstractas
Curso de TypeScript: Programación Orientada a Objetos y Asincronismo
Contenido del curso
Fundamentos de POO
POO Avanzada
Asincronismo y consumo de APIs
Genéricos
Próximos pasos
Clases abstractas
Curso de TypeScript: Programación Orientada a Objetos y Asincronismo
Contenido del curso
Clases abstractas
Irving Juárez
Estudiante
Ronaldo Delgado
Estudiante
Miguel Angel Reyes Moreno
Estudiante
Andrés Felipe Eslava Zuluaga
Estudiante
Sebastián Álvarez Aristizabal
Estudiante
Carlos Rodríguez
Estudiante
Víctor Andrés Córdova Poma
Estudiante
David Higuera
Estudiante
Rodrigo Andrés Moreno Pertúz
Estudiante
Ezequiel Dastolfo
Estudiante
Luis Herrera
EstudianteJean Bustamante
Estudiante
Eminson Mendoza
Estudiante
Oier Solabarrieta Egues
Estudiante
David Rangel
Estudiante
Carlos Alberto De Avila Suro
Estudiante
Diego Fernando Velesaca Orellana
Estudiante
Juan Carlos Pinzón
Estudiante
Alfonso Neil Jiménez Casallas
EstudianteRonaldo Delgado
EstudianteEn conclusión, cada vez que implementamos una clase abstracta, no podemos crear instancias de esa clase, si no solo de las clases hijas.
abstract class Pet {} // no instancias de esta clase class Dog extends Pet {} // de esta si podemos
tremendo!
Las clases abstractas son tan 'genericas' que no tiene sentido que sean instanciadas. Usamos la keyword abstract.
Es una excelente definición!!
También me gastaría aportar que los métodos de una clase pueden ser abstractos, eso significa que no van a tener una implementación como tal, si no que cuando se extienda la clase que lo contiene ( que también debe ser abstracta ) se debe de implementar el método. Es una forma de hacer que las clases hijas obligatoriamente tengan que implementar ciertos métodos.
Aquí les dejo un ejemplo.
enum DIRECTIONS { UP = 1, DOWN = -1, LEFT = -1, RIGHT = 1 } export abstract class Animal { public name : string; protected position : [number , number ] = [0,0]; constructor(name:string){ this.name = name; } move(direction : DIRECTIONS) : number[]{ if(direction === DIRECTIONS.UP || direction===DIRECTIONS.DOWN){ this.position[0] += direction; }else{ this.position[1] += direction; } return this.position; } abstract sound() : void ; } class Dog extends Animal{ public owner : string; constructor(name: string, owner: string){ super(name); this.owner = owner; } sound(): void { console.log("WOOF"); } } const Loki = new Dog("Loki","Nico"); console.log(Loki.move(DIRECTIONS.DOWN)); Loki.sound();
Ya es definitivo, hoy firmo el divorcio con javascript y me caso con typescript!
Abstract se puede usar como interface, ya que con interface no se puede tener atributos o métodos private o protected. Estos solo pueden se public.
Ejemplo:
abstract class Base { protected abstract getName(name: string): string; protected abstract height: number; } class Derived extends Base { constructor ( protected height: number = 5, ) { super(); } protected getName(name: string) { return "world" + name; } }
Si. Y considero más práctico el uso de interfaces para ese propósito
export abstract class Programa{ constructor( protected name: string, protected owner: string, ){} codifica(param: number, param2: number){ console.log(`${this.name} codifica ${param}x, ${param2}y mas rapido`); } about(){ console.log(`Hola soy ${this.name},y mi propietario es: ${this.owner}`); } protected compila(){ console.log(`${this.name} compilando...\n`); } } export class Editor extends Programa{ programa(){ this.compila() } } const editor1 = new Editor("VSCODE", "Microsoft"); editor1.codifica(1,2); editor1.about(); editor1.programa(); const editor2 = new Editor("CHEATCODES", "CheatModes4"); editor2.codifica(10,30); editor2.about(); editor2.programa();
Gracias por dar ejemplos de casos reales! Aportan mucho contexto a la explicación.
Excelente curso
El mejor curso de Platzi
Le pregunté a ChatGPT sobre las diferencias con una interfaz ya que se ven parecidos los dos conceptos:
Sí, es cierto que las clases abstractas y las interfaces comparten algunas similitudes, ya que ambas se utilizan para definir estructuras y contratos para las clases derivadas. Sin embargo, también existen diferencias importantes entre ellas:
Clases Abstractas:
Pueden contener tanto métodos concretos (con implementación) como métodos abstractos (sin implementación).
Pueden tener propiedades y campos concretos.
Pueden heredar de una sola clase, abstracta o no.
Las clases derivadas solo pueden heredar de una clase abstracta.
Interfaces:
Solo pueden contener métodos abstractos (sin implementación) y propiedades sin cuerpo.
No pueden tener campos concretos.
Pueden ser implementadas por múltiples clases y objetos.
Las clases y objetos pueden implementar múltiples interfaces.
En resumen, las clases abstractas permiten definir una jerarquía de clases con métodos y propiedades concretos y abstractos, mientras que las interfaces son más flexibles y se centran principalmente en definir contratos que deben cumplirse por múltiples clases. La elección entre usar una clase abstracta o una interfaz dependerá de la estructura y el diseño de tu código y de si deseas proporcionar implementaciones concretas o solo definir contratos.
Las clases abstractas son plantillas que no se pueden instanciar directamente y pueden contener métodos abstractos (sin implementación) y métodos concretos (con implementación). Se utilizan para definir una interfaz común para un conjunto de clases que comparten comportamiento.
Ejemplo:
Clase abstracta: Animal
hacerSonido()dormir()Clases concretas: Perro y Gato que heredan de Animal y deben implementar hacerSonido().
Usa clases abstractas cuando desees asegurar que todas las subclases implementen ciertos métodos, manteniendo una estructura organizada.
Si quieren aprender sobre programación orientada a objetos, les recomiendo mucho que aprendan Java. Para mí, es el mejor lenguaje de programación para aprender este paradigma. Una vez aprendido los conceptos básicos de POO con Java, pasar a utilizar POO en otros lenguajes es sumamente sencillo.
El Curso de Java SE Orientado a Objetos de Anahí Salgado es increíble, se los recomiendo muchooo!!
Gracias por los ejemplos, profesor, son muy ilustrativos. :)
Es una forma de restringir la creación de objetos de una clase base o clases padre, lo explico a continuación, dada una clase Animal como la de el siguiente ejemplo
export class Animal {
constructor(protected name: string) {}
move() {
console.log('Moving along!');
}
greeting() {
return Hello, I'm ${this.name};
}
}
Puede ser instanciada de la siguiente manera
const animal = new Animal(“Doggi”)
Pero si al definirla le agregamos la palabra abstract antes de class, es decir así
export abstract class Animal {
constructor(protected name: string) {}
Ya no la podremos instanciar directamente como lo hicimos arriba, solo la podremos heredar a otra clase con la palabra clave extends para que se haga una definición más precisa como por ejemplo
class Perro extends Animal {
constructor(
name: string,
public owner: string
) {
super(name);
}
}
En este concepto de clases abstractas se basa en patrón de diseño creacional Abstract Factory ?
No, el patrón es algo diferente echale un ojo a lo siguiente:
tremenda introducción a los patrones creacionales en TypeScript como, por ejemplo, Factory Method, comparto el link a un ejemplo del código
Gua no sabia nada sobre este concepto, Gracias profe