Contenido del curso
Fundamentos de POO
POO Avanzada
Asincronismo y consumo de APIs
Genéricos
Próximos pasos
Interfaces
Contenido del curso
Axel Enrique Galeed Gutierrez
Yuliam Rivera González
Jean Bustamante
Migdualy Alejandra Gonzalez Martinez
Diego Ivan Nacimiento
Germán Jabloñski
Andrés Muñoz
Daniel Camacho
Christian Valenzuela
Migdualy Alejandra Gonzalez Martinez
Ronaldo Delgado
Miguel Angel Reyes Moreno
William Cortes
Jesús Patricio Pereira Matus
Jesús Patricio Pereira Matus
fabio andres zamora osorio
Edson Lazo
Víctor Andrés Córdova Poma
Víctor Andrés Córdova Poma
Daniel Camacho
Eduardo Robles
Carlos Alberto De Avila Suro
David Cardenas Guzman
Paola Alapizco
John Carlos Espitia Rivera
Adriana Paredes Salinas
Manuel Calle Pérez
Brahyan Antonio Martinez Madera
Juan Castro
Profesorfabio andres zamora osorio
Kevin Daniel Guzman Delgadillo
Les comparto mis apuntes. :D
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.
Son horribles los ejemplos de animales y vehículos 😿
Una interfaces se implementan con la palabra reservada implements
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
¿Por qué usar implements con una interfaz cuando se puede utilizar la herencia de clases?
Una de las diferencias es que la interface no define nada acerca de la implementación, lo que da a entender que esta implementación va estar a cargo de cada clase. En cambio usando herencia pueden surgir preguntas como utilizo el método de la clase padre o escribo uno nuevo en la clase hija
por el contrato, basicamente estas en la obligacion de implementar lo que dedfinas en la interfaz, o otra opcion si prefieres trabajar con clases seria extendiendo de una clase abstracta tambien te obliga a implementar esos metodos, lo malo es que no puedes crear instancias de ella, solo a las subclases dentro del arbol de herencia
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
excelente implementar interfaces para nuestros proyectos así todo será mas robusto
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
las interfaces es como dijo nico, un contrato, da igual como lo implementen pero deben tenerlo en caso de que una interfaz tenga un metodo da igual como lo implementes en otra clase pero debe tenerlo si o si
si quieren ver este paradigma al 100 les recomiendo ver java porque ahi se explica mejor con los diagramas UML entre otras cosas
Esto aprendiendo poo en typescript y quisiera saber cual es el beneficio de crear interfaces e implementarlas en una clase ya que el codigo de la interface se repite en la clase la unica diferencia es que en la clase los metodos tienen implementacion, osea,¿no seria mas simple crear una clase con todos los metodos y atributos de las interfaces y no crear las interfaces?
Hola Fabio, La idea de utilizar una interfaz, es poder definir un comportamiento estandarizado para distintos objetos. Para continuar el ejemplo del profesor, digamos que nosotros tenemos un método que nos trae el driver de la base de datos de acuerdo a una variable de entorno, nosotros no sabemos exactamente cual de las clases nos traerá este método, pero si sabemos que devolverá un objeto con la interfaz 'Driver', a continuación detallo este metodo:
function getConnectionFromConfig(): Driver{ let connectionType: string = process.env.CONECTION_TYPE; if(connectionType == 'ORACLE'){ return new OracleDriver('database', 'password', 20); }else{ return new PostgresDriver('database', 'password', 20, 100); } }
Como puedes ver, este método devolverá el driver de Oracle si la variable de entorno 'CONECTION_TYPE' es igual 'ORACLE' y en caso de no serlo devolverá el driver de Postgres.
Esto no supondra ningun problema para nosotros, ya que sabemos que este metodo devuelve un objeto con la interfaz driver, por lo que podemos simplemente llamar a los metodos del objeto que devuelve el metodo, de la siguiente forma:
let databaseConnection: Driver = getConnectionFromConfig(); databaseConnection.connect(); databaseConnection.disconnect();
De esta manera nosotros podemos intercambiar el driver, solo con cambiar la variable de entorno CONECTION_TYPE sin cambiar ni una linea de codigo.
Este es solo un ejemplo, pero usar interfaces tiene muchas ventajas. te recomiendo leer este post de stack overflow donde dan varios ejemplos de usos de interfaces y su utilidad.
Saludos!
Se puede tener atributos o métodos de tipo private o protected implementando una interface? Lo digo porque al intentarlo me sale error, y me dice que la interface no tiene esa propiedad o método en la interface de tipo private o protected. Sin embargo, al colocar el tipo dentro de la interface me sale error, ya que no puede ser colocado en la interface.
Al parecer solo se puede resolver ese problema usando clases abstractas.
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; } }
normalmente los metodos en las interfacces el modificador no va private, ya que se espera que la implementacion la hagan en otro archivo,en su mayoria son publicos ya que se crean con la finalidad de que lo implementen varios paquetes de clases o por fuera de arboles de herencia, por eso no es usual definirlo como protected o private, existe un modificador default que te permite ahcer la implementacion en el mismo, pero no se en ts como seria
hay manera de implementar interfaces en clases hechas con funciones?
Cuando vamos a crear una clase en la que necesitamos que ts nos avise, vele y nos obligue para que dicha clase cuente con una norma, como el tener que contar con una lista de propiedades y métodos, es útil usar interfaces. son como un contrato que obliga a la clase a implementar los requisitos estipulados en la interface
Hasta hoy hemos trabajado las interfases mas o menos como Types
interface Driver{
database:string;
password:string;
port:number;
}
const driver:Driver = {
database:"",
password:"",
port:23
}
Notese que el nombre de la interface empieza con mayuscula.
Para implementas la interface, usamos la palabra implements al definir la clase
class PostgresDriver implements Driver{
constructor(
public database:string,
public password:string,
public port:number){}
}
class OracleDriver implements Driver{
}
Y si no incluimos las tres propiedades (database, password y port) estipuladas en la definición de la interface Dirver, obtendremos un error.
Tambien podemos indicar metodos o funciones en la deficnicion de la interface como connect en el siguiente ejemplo:
interface Driver{
database:string;
password:string;
port:number;
connect():void
}
Solo hemos añadido los parentesis despues del nombre del metodo y como podrás deducir, esto obligare a que cada clase que implemente la interface Driver contenga un método llamado connect
class PostgresDriver implements Driver{
constructor(
public database:string,
public password:string,
public port:number){}
connect(){
console.log("Conectado a la base de datos")
}
}
Todas las propiedades o metodos definidas en la interface se deben definir como publicos en la clase, si quieres algo privado, eso ya seria una caracteristica propia de la clase que no importa si es que ya cumpliste con lo estipulado en la interface
Por qué es necesario colocar los {} para el constructor de manera obligatoria en este caso?
Hola David. El constructor es una función especial de las clases, y su sintaxis es igual a cualquier otra función.
constructor(params){}.
El constructor al ser una función debe seguir la sintaxis del lenguaje, por lo tanto si o si debe llevar las llaves { } a pesar de que el cuerpo este vacío.
.
:writing_hand: En las clases la palabra recercada function no se coloca antes del nombre.
Cuando defines una interface puedes definir métodos y atributos protected o solo public? Entiendo que private no es valido pero protected parece una definición válida
En TypeScript, las interfaces solo pueden definir miembros públicos (public). No es posible definir miembros protegidos (protected) o privados (private) en una interfaz. Esto se debe a que las interfaces en TypeScript se utilizan principalmente para especificar la forma (forma o estructura) de los objetos y no para encapsular datos o definir detalles de implementación.
Alguien sabe en que curso utilizan typeorm q el profesor lo menciona. Gracias
En el curso de nestjs
Haciendo pruebas me di cuenta de que en typescript una clase puede implementar multiples interfaces, entonces tuve una duda ¿si una clase implementa una interface1 y una interface2 donde ambas tienen el mismo nombre y tipos en un metodo, entonces, al crear la implementacion de dicho metodo en la clase cual metodo se esta implementando el de la interface1 o el de la interface2?
Las Interfaces de Typescript tiene su pero y es el siguiente: Cuando estas implementando algo de arquitectura de software (usando patrones de diseño, en específico singleton), tu no puedes defir la interface cómo tipo de dato esperado al injectar tu servicio, ya que al transpilarse a javascript, Typescript no interpreta la interface cómo un valor válido.