Relaciones entre clases en UML

Curso de Introducción a los Patrones de Diseño de Software

Contenido del curso

Introducción

El software y la ingeniería

Diseño de software

Patrones de diseño

POO

Conclusiones finales

14
Reflexiones finales sobre patrones de diseño
08:58 min

Cursos Empresas Blog Live Conf Eventos Precios

0:0014:29

Relaciones entre clases en UML

Curso de Introducción a los Patrones de Diseño de Software

Clase 13 de 14

Clase 13 / 14

En la programación orientada a objetos (POO), existen diferentes tipos de relaciones que pueden establecerse entre clases para modelar las interacciones y dependencias entre ellas. Algunos de los tipos de relaciones más comunes son los siguientes: . Asociación: La asociación es una relación básica y general entre dos clases. En esta relación, una clase hace referencia a otra clase como un miembro o atributo. Puede ser una relación unidireccional o bidireccional. Por ejemplo, en un sistema de gestión de una escuela, la clase "Estudiante" puede tener una asociación con la clase "Curso", ya que cada estudiante está asociado con uno o más cursos. . Agregación: La agregación es una relación de todo a parte, donde una clase contiene una referencia a otra clase, pero la otra clase puede existir de manera independiente. En otras palabras, la clase "contenedora" tiene una asociación con la clase "contenido", pero el contenido puede existir sin el contenedor. Por ejemplo, en un sistema de gestión de una biblioteca, la clase "Biblioteca" puede tener una agregación con la clase "Libro", ya que los libros pueden existir por separado y también pueden ser parte de la biblioteca. . Composición: La composición es una relación más fuerte de todo a parte que la agregación. En esta relación, una clase contiene a otra clase y la parte no puede existir sin el todo. Es una relación de dependencia fuerte. Por ejemplo, en un sistema de una computadora, la clase "Computadora" puede tener una composición con la clase "Procesador", ya que un procesador es una parte esencial de una computadora y no puede existir sin ella. . Herencia: La herencia es una relación jerárquica entre clases, donde una clase llamada "clase derivada" hereda los atributos y métodos de otra clase llamada "clase base" o "superclase". La clase derivada puede agregar nuevos atributos y comportamientos específicos, además de heredar los de la clase base. Esto permite la reutilización de código y la creación de jerarquías de clases. Por ejemplo, en un sistema de gestión de una tienda, puede haber una clase base "Producto" y clases derivadas como "Ropa", "Electrónica" o "Alimentos". . Dependencia: La dependencia es una relación en la que una clase requiere o depende de otra clase en algún punto. Por ejemplo, si una clase A utiliza un objeto de una clase B como parámetro en un método, hay una dependencia entre ambas clases. La clase A depende de la clase B para realizar una determinada operación.

Comparto algunos ejemplos como ejercicios que realice:

// dependencia
// su uso es momentaneo


class Motor {
  encender() {
    console.log('Motor encendido')
  }
}


class Carro {
  encenderCarro(motor: Motor) {
    motor.encender()
  }
}


const unMotor = new Motor()
const miCarro = new Carro()
console.log(miCarro.encenderCarro(unMotor))


// una clase tiene usualmente como atributo a otra clase
// es permanente su acceso a la otra clase
class Comida {
  pollo() {
    console.log('pollo')
  }
}


class Plato {
  comida: Comida
  constructor(comida: Comida) {
    this.comida = comida
  }
  servir() {
    this.comida.pollo()
  }
}


const comida = new Comida()
const plato = new Plato(comida)


// implementacion, aqui las clases obedencen a una interfaz
interface Animal {
  patas: number
  cabeza: number
  cola: boolean
}


class Gato implements Animal {
  patas: number
  cabeza: number
  cola: boolean
  constructor(patas: number, cabeza: number, cola: boolean) {
    this.patas = patas
    this.cabeza = cabeza
    this.cola = cola
  }
}


// en la herencia una clase hereda de otra


class Mama {
  ojos: string
  cejas: string
  cabello: string
  constructor() {
    this.ojos = 'verdes'
    this.cejas = 'pobladas'
    this.cabello = 'rizado'
  }
}


class Hija extends Mama {
  nariz: string
  constructor(ojos: string, cejas: string, cabello: string) {
    super()
    this.nariz = 'chata'
  }
}


// agregacion, el elemento que llama al elemento padre no depende de este, su ciclo de vida es libre


class ComboHamburguesa {
  hamburguesa: boolean
  papas: boolean
  refresco: boolean
  pure: boolean
  constructor(
    hamburguesa: boolean,
    papas: boolean,
    refresco: boolean,
    pure: boolean,
  ) {
    this.hamburguesa = hamburguesa
    this.papas = papas
    this.refresco = refresco
    this.pure = pure
  }
}


class Orden {
  orden: Array<any>
  constructor() {
    this.orden = []
  }
  pedirOrden(combo: ComboHamburguesa) {
    this.orden.push(combo)
  }
}


const combo = new ComboHamburguesa(true, true, false, true)
const orden = new Orden()
orden.pedirOrden(combo)


// composicion, de la clase padre dependera el ciclo de vida de las hijas, el objeto suele crear instancias dentro de su constructor, relacion ligada, fuerte
class Pizza {
  ingredientes: {
    queso: string
    masa: string
  }
  constructor() {
    this.ingredientes = {
      queso: 'queso',
      masa: 'masa',
    }
  }
}


class PizzaHawaiana {
  base: Pizza
  insumoDistintivo: string
  constructor() {
    this.base = new Pizza()
    this.insumoDistintivo = 'piña'
  }
  getPizza() {
    console.log('La pizza contiene: ', {
      ...this.base.ingredientes,
      distintivo: this.insumoDistintivo,
    })
  }
}