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.

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

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

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.