No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Clases abstractas

13/25
Recursos

Aportes 8

Preguntas 0

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

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 鈥榞enericas鈥 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