Clases abstractas

tremendo!

Miguel Angel Reyes Moreno

Las clases abstractas son tan 'genericas' que no tiene sentido que sean instanciadas. Usamos la keyword abstract.

Andrés Felipe Eslava Zuluaga

Es una excelente definición!!

Sebastián Álvarez Aristizabal

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

Carlos Rodríguez

Ya es definitivo, hoy firmo el divorcio con javascript y me caso con typescript!

Víctor Andrés Córdova Poma

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

David Higuera

Si. Y considero más práctico el uso de interfaces para ese propósito

Rodrigo Andrés Moreno Pertúz

Hace 5 años

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

Ezequiel Dastolfo

Gracias por dar ejemplos de casos reales! Aportan mucho contexto a la explicación.

Excelente curso

Luis Herrera

El mejor curso de Platzi

Jean Bustamante

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.

Eminson Mendoza

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
- Método abstracto: hacerSonido()
- Método concreto: 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.

Oier Solabarrieta Egues

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

David Rangel

Hace 9 meses

Gracias por los ejemplos, profesor, son muy ilustrativos. :)

Carlos Alberto De Avila Suro

Hace 6 meses

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

}

Diego Fernando Velesaca Orellana

En este concepto de clases abstractas se basa en patrón de diseño creacional Abstract Factory ?

Juan Carlos Pinzón

No, el patrón es algo diferente echale un ojo a lo siguiente:

Alfonso Neil Jiménez Casallas

tremenda introducción a los patrones creacionales en TypeScript como, por ejemplo, Factory Method, comparto el link a un ejemplo del código

Ronaldo Delgado