Design Patterns in Go
  • Portada
  • Introducción
  • Publicación
  • Parte I
    • Sobre Go
    • POO en Go
      • Objetos
      • Herencia / Composición
      • S.O.L.I.D
  • Parte II
    • Patrones de Diseño
      • GoF
      • Patrones de Comportamiento
        • Strategy
        • Chain of Responsibility
        • Command
        • Template Method
        • Memento
        • Interpreter
        • Iterator
        • Visitor
        • State
        • Mediator
        • Observer
      • Patrones Creacionales
        • Singleton
        • Builder
        • Factory Method
        • Abstract Factory
        • Prototype
      • Patrones Estructurales
        • Composite
        • Adapter
        • Bridge
        • Proxy
        • Decorator
        • Facade
        • Flyweight
  • Parte III
    • Conclusiones
    • Acerca De
  • Recursos de interés
  • Glosario
Con tecnología de GitBook
En esta página
  • Propósito
  • También conocido como
  • Estructura
  • Participantes
  • Implementación
  • Código de ejemplo

¿Te fue útil?

  1. Parte II
  2. Patrones de Diseño
  3. Patrones Estructurales

Adapter

AnteriorCompositeSiguienteBridge

Última actualización hace 5 años

¿Te fue útil?

Propósito

Según el libro "Patrones de Diseño" el patrón Adapter "convierte la interfaz de una clase en otra interfaz que es la que esperan los clientes. Permite que cooperen clases que de otra forma no podrían por tener interfaces incompatibles".

También conocido como

Wrapper (Envoltorio)

Estructura

Participantes

  • Objetivo:

    • define la interfaz específica del dominio que usa el Cliente.

  • Cliente:

    • colabora con variables que se ajustan a la interfaz Objetivo.

  • Adaptable:

    • define una interfaz existente que necesita ser adaptada.

  • Adaptador:

    • adapta la interfaz de Adaptable a la interfaz Objetivo.

Implementación

No se observan impedimentos y/o modificaciones de la estructura original del patrón para su implementación en Go.

Código de ejemplo

En este ejemplo queremos que un juego de RPG se pueda adaptar a un nuevo tipo de personaje (Magos) que no comparte las mismas características que los guerreros originales (Elfos). Para esto es necesario realizar un adaptador para que un Mago pueda atacar como un Elfo.

Implementación:

// Objetivo
type Gerrero interface {
    UsarArma() string
}

type Elfo struct{}

func (e *Elfo) UsarArma() string {
    return "atacando con arco y flecha"
}

// Adaptable
type GerreroMagico interface {
    UsarMagia() string
}

type Mago struct{}

func (m *Mago) UsarMagia() string {
    return "atacando con magia"
}

// Adaptador
type MagoAdaptador struct {
    gerrero GerreroMagico
}

func (ma *MagoAdaptador) UsarArma() string {
    return ma.gerrero.UsarMagia()
}

// Cliente
type Jugador struct {
    guerrero Gerrero
}

func (j *Jugador) Atacar() string {
    return j.guerrero.UsarArma()
}

Se puede probar la implementación del patrón de la siguiente forma:

jugadorA := &Jugador{&Elfo{}}
fmt.Printf("Jugador A: %s\n", jugadorA.Atacar())

jugadorB := &Jugador{&MagoAdaptador{&Mago{}}}
fmt.Printf("Jugador B: %s\n", jugadorB.Atacar())

|

Atención: Esta publicación se encuentra abandonada. Puede acceder a la versión vigente en

Código de ejemplo
Ejecutar código
https://leanpub.com/designpatternsingo
[29]