Clases abstractas

En 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

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

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

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

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

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

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:

1. Pueden contener tanto métodos concretos (con implementación) como métodos abstractos (sin implementación).

2. Pueden tener propiedades y campos concretos.

3. Pueden heredar de una sola clase, abstracta o no.

4. Las clases derivadas solo pueden heredar de una clase abstracta.

Interfaces:

1. Solo pueden contener métodos abstractos (sin implementación) y propiedades sin cuerpo.

2. No pueden tener campos concretos.

3. Pueden ser implementadas por múltiples clases y objetos.

4. 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.

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

Excelente curso