# TypeScript: Uso de interfaces para el Polimorfismo
![alt](https://photos.collectednotes.com/photos/11574/4011e1e3-5d02-424f-a34c-4471643da51a)

La razón principal para usar interfaces es lograr el polimorfismo y proporcionar a los desarrolladores la posibilidad de implementar a su manera en el futuro los métodos de la interfaz.

Supongamos que tenemos una interfaz y tres clases:


```javascript

interface Conexion {
    Conectarse(): boolean;
}

```

Esta es la interfaz del conectador. Ahora vamos a implementar la comunicación Wifi.


```javascript

export class ConexionWifi implements Conexion {

    public Conectarse(): boolean{
        console.log("Conectandose via WiFi");
        console.log("Obteniendo dirección IP");
        console.log("Conectado");
        return true
    }

}

```

Aquí hemos desarrollado nuestra clase concreta llamada **ConexionWifi** que tiene su propia implementación de tipo **Conexion**.

---

Ahora estamos creando nuestro **Sistema** que tiene un componente **Conexion**. Esto se llama inyección de dependencia.


```javascript

export class Sistema {
    constructor(private con: Conexion) { 
	    //Injectamos el tipo Conexion
        con.Conectarse()
    }
}

```

### Miremos esta linea de código...

```javascript
constructor(private con: Conexion)
```

**Conexion** es una interfaz y debe tener el método **Conectarse().**

Ahora, como **Conexion** es una interfaz, la clase  **Sistema** tiene mucha más flexibilidad.

Podemos pasar cualquier tipo que haya implementado la interfaz **Conexion**. 
En el futuro, el desarrollador logrará más flexibilidad. 

---

Por ejemplo, ahora el desarrollador quiere añadir un módulo de conexión Bluetooth:



```javascript

export class ConexionBluetooth implements Conexion {

    public Conectar(): boolean {
        console.log("Conectandose via Bluetooth");
        console.log("Emparejando PIN");
        console.log("Conectado correctamente");
        return true
    }

}

```

Vemos que **Wifi** y **Bluetooth** tienen su propia implementación.
Hay una manera diferente de conectarse. 

Así que podemos pasar cualquiera de ellos a la clase **Sistema** como parámetro del constructor. Esto se llama **polimorfismo**. 

La clase **Sistema** ahora no es consciente de si es Bluetooth o Wifi. Incluso podemos añadir otro módulo de comunicación como Infrarojo, Bluetooth5 y lo que sea simplemente implementando la interfaz **Conexion**.

Esto se llama [Duck Typing](https://es.wikipedia.org/wiki/Duck_typing). El tipo de conector es ahora dinámico ya que **Conectar()** es sólo un marcador de posición y él desarrollador lo implementa como propio.

