Interfaces

Les comparto mis apuntes. 😄

Interfaces en clases

Las interfaces en clases funcionan como contratos, nos permiten tipar tanto los atributos como los métodos.

Aquí no podemos utilizar encapsulamiento, por defecto todos los atributos y métodos son públicos.

Implements

Tiene la misma sintaxis cuando aplicamos herencias en las clases, pero implements no es una herencia, es un contrato que nos dice que nuestra clase tiene que cumplir con un estándar que es la interface.

Este contrato es tanto como para los parámetros como para los métodos.

Sintaxis

interface NameInterface {
	statements
}

class NameClass implements NameInterface {
	constructor (
		propertiesOfInterface
	) {
		statements
	}

	methodOfInterface (): dataType { statements }
}

Código de la clase

export interface Driver {
    database: string;
    password: string;
    port: number;

    conect (): void;
    disconnect (): void;
    isConeected (name: string): boolean;
}

// const driver: Driver = {
//     database: '',
//     password: '',
//     port: 23,
// }

class PostresDriver implements Driver{
    constructor (
        public database: string,
        public password: string,
        public port: number,
    ) {

    }

    conect (): void {}
    disconnect (): void {}
    isConeected (name: string): boolean {
        return true;
    }
}

class Oracle implements Driver {
     constructor (
        public database: string,
        public password: string,
        public port: number,
    ) {

    }
    conect (): void {}

    disconnect (): void {}
    isConeected (name: string): boolean {
        return true;
    }
}

Me encantó que mostrara un ejemplo de la vida real, y no solamente se quedara con los ejemplos tipicos de animales y cosas.

Una interfaces se implementan con la palabra reservada implements

Es increible que se muestren ejemplos de la vida real, es muy util ya que asi nos ayuda a implementar este tipo de cuestiones

No es una herencia, es un estandar que se debe cumplir porque previamente ya fue definido

Cabe recordar que no siempre se deben utilizar interfaces para las clases, sino solo cuando sean convenientes, que son los casos en los que vamos a tener varias clases que van a compartir unas mismas propiedades y/o métodos
La idea es tener una interfaz para varias clases y no una interfaz para cada clase

Podemos usar las interfaces como ‘contratos’ para que las clases cumplan una serie de requisitos.

En VScode puedes colcar el cursor sobre el nombre de la clase, en la parte superior izquierda sobre la palabra class, sale un ícono(como un bombilllito) que al clickearlo te despliega un menú, si selecionas:
-Inplements Interface ‘NameInterface’…
le agrega a nuestra clase con todos los atributos de la interface

no entiendo 😦

Class Code #12

export interface Driver {
  database: string;
  password: string;
  port: number;


  connect() :void;
  disconnect(): void;
  isConnected(name: string):boolean;
}

/* const driver: Driver = {
  database: '',
  password: '',
  port: 23
} */

class PostgressDriver implements Driver {
  constructor(
    public database: string,
    public password: string,
    public port: number,
    private host: number
  ) {}

  connect(): void {

  }
  disconnect(): void {

  }
  isConnected(name: string): boolean {
    return true;
  }
}

class OracleDriver implements Driver {
  constructor(
    public database: string,
    public password: string,
    public port: number
  ) {}

  connect(): void {

  }
  disconnect(): void {

  }
  isConnected(name: string): boolean {
    return false;
  }
}

Contrato: Acuerdo, generalmente escrito, por el que dos o más partes se comprometen recíprocamente a respetar y cumplir una serie de condiciones.