El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Interfaces

Siguiente ►
►

Las interfaces en Go son una parte fundamental del lenguaje que permite definir comportamientos que pueden ser implementados por diferentes tipos. A diferencia de otros lenguajes de programación, en Go no se necesita declarar explícitamente que un tipo implementa una interfaz; si un tipo tiene los métodos que la interfaz requiere, entonces implementa esa interfaz.

Conceptos Clave

  1. Definición de una Interfaz: Una interfaz es un conjunto de métodos.
  2. Implementación Implícita: Un tipo implementa una interfaz si tiene todos los métodos que la interfaz requiere.
  3. Uso de Interfaces: Las interfaces permiten escribir código más flexible y reutilizable.

Definición de una Interfaz

En Go, una interfaz se define utilizando la palabra clave interface. Aquí hay un ejemplo de una interfaz simple:

package main

import "fmt"

// Definición de la interfaz
type Describible interface {
    Describir() string
}

// Tipo que implementa la interfaz
type Persona struct {
    Nombre string
    Edad   int
}

// Método que implementa la interfaz Describible
func (p Persona) Describir() string {
    return fmt.Sprintf("Nombre: %s, Edad: %d", p.Nombre, p.Edad)
}

func main() {
    var d Describible
    p := Persona{"Juan", 30}
    d = p
    fmt.Println(d.Describir())
}

Explicación del Código

  1. Definición de la Interfaz: La interfaz Describible tiene un método Describir que devuelve un string.
  2. Implementación de la Interfaz: El tipo Persona tiene un método Describir que cumple con la interfaz Describible.
  3. Uso de la Interfaz: En la función main, se declara una variable de tipo Describible y se le asigna una instancia de Persona. Luego, se llama al método Describir a través de la interfaz.

Implementación Implícita

En Go, no es necesario declarar explícitamente que un tipo implementa una interfaz. Si un tipo tiene los métodos que la interfaz requiere, entonces implementa esa interfaz automáticamente.

Ejemplo

package main

import "fmt"

// Definición de la interfaz
type Describible interface {
    Describir() string
}

// Tipo que implementa la interfaz
type Producto struct {
    Nombre  string
    Precio  float64
}

// Método que implementa la interfaz Describible
func (p Producto) Describir() string {
    return fmt.Sprintf("Producto: %s, Precio: %.2f", p.Nombre, p.Precio)
}

func main() {
    var d Describible
    prod := Producto{"Laptop", 999.99}
    d = prod
    fmt.Println(d.Describir())
}

Explicación del Código

  1. Definición de la Interfaz: La interfaz Describible tiene un método Describir que devuelve un string.
  2. Implementación de la Interfaz: El tipo Producto tiene un método Describir que cumple con la interfaz Describible.
  3. Uso de la Interfaz: En la función main, se declara una variable de tipo Describible y se le asigna una instancia de Producto. Luego, se llama al método Describir a través de la interfaz.

Uso de Interfaces

Las interfaces permiten escribir funciones que pueden trabajar con diferentes tipos, siempre y cuando esos tipos implementen la interfaz requerida.

Ejemplo

package main

import "fmt"

// Definición de la interfaz
type Describible interface {
    Describir() string
}

// Tipos que implementan la interfaz
type Persona struct {
    Nombre string
    Edad   int
}

func (p Persona) Describir() string {
    return fmt.Sprintf("Nombre: %s, Edad: %d", p.Nombre, p.Edad)
}

type Producto struct {
    Nombre  string
    Precio  float64
}

func (p Producto) Describir() string {
    return fmt.Sprintf("Producto: %s, Precio: %.2f", p.Nombre, p.Precio)
}

// Función que usa la interfaz
func ImprimirDescripcion(d Describible) {
    fmt.Println(d.Describir())
}

func main() {
    p := Persona{"Juan", 30}
    prod := Producto{"Laptop", 999.99}

    ImprimirDescripcion(p)
    ImprimirDescripcion(prod)
}

Explicación del Código

  1. Definición de la Interfaz: La interfaz Describible tiene un método Describir que devuelve un string.
  2. Implementación de la Interfaz: Los tipos Persona y Producto tienen métodos Describir que cumplen con la interfaz Describible.
  3. Uso de la Interfaz: La función ImprimirDescripcion acepta un parámetro de tipo Describible y llama al método Describir. En la función main, se pasan instancias de Persona y Producto a ImprimirDescripcion.

Ejercicio Práctico

Ejercicio

  1. Define una interfaz Operable con un método Operar que toma dos enteros y devuelve un entero.
  2. Crea dos tipos Suma y Multiplicacion que implementen la interfaz Operable.
  3. Escribe una función Calcular que acepte un Operable y dos enteros, y devuelva el resultado de llamar al método Operar.

Solución

package main

import "fmt"

// Definición de la interfaz
type Operable interface {
    Operar(a int, b int) int
}

// Tipos que implementan la interfaz
type Suma struct{}

func (s Suma) Operar(a int, b int) int {
    return a + b
}

type Multiplicacion struct{}

func (m Multiplicacion) Operar(a int, b int) int {
    return a * b
}

// Función que usa la interfaz
func Calcular(o Operable, a int, b int) int {
    return o.Operar(a, b)
}

func main() {
    suma := Suma{}
    multiplicacion := Multiplicacion{}

    fmt.Println("Suma:", Calcular(suma, 3, 4))               // Salida: Suma: 7
    fmt.Println("Multiplicación:", Calcular(multiplicacion, 3, 4)) // Salida: Multiplicación: 12
}

Explicación del Código

  1. Definición de la Interfaz: La interfaz Operable tiene un método Operar que toma dos enteros y devuelve un entero.
  2. Implementación de la Interfaz: Los tipos Suma y Multiplicacion implementan el método Operar de la interfaz Operable.
  3. Uso de la Interfaz: La función Calcular acepta un Operable y dos enteros, y devuelve el resultado de llamar al método Operar. En la función main, se crean instancias de Suma y Multiplicacion y se pasan a Calcular.

Conclusión

Las interfaces en Go son una herramienta poderosa para escribir código flexible y reutilizable. Permiten definir comportamientos que pueden ser implementados por diferentes tipos sin necesidad de declarar explícitamente la implementación. Esto facilita la creación de funciones y estructuras de datos que pueden trabajar con una variedad de tipos, mejorando la modularidad y la mantenibilidad del código.

En el próximo tema, exploraremos la reflexión en Go, que nos permitirá inspeccionar y manipular tipos y valores en tiempo de ejecución.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados