Módulo 1 de 4 — Vista Lógica
3.1 Diagramas de Clases
El diagrama de clases es el artefacto estrella de la Vista Lógica. Representa la estructura estática de un sistema orientado a objetos: qué elementos existen, qué información contienen, qué operaciones ejecutan y cómo colaboran entre sí.
¿Qué objetos existen?
Las clases y entidades fundamentales que modelan el dominio del sistema.
¿Qué datos contienen?
Atributos, tipos de datos y niveles de visibilidad (- privado, + público, # protegido).
¿Qué pueden hacer?
Constructores, métodos de negocio, getters/setters y firmas de retorno.
¿Cómo se relacionan?
Herencia (extends), contratos (implements), asociación (◇) y composición (◆).
💡 El plano universal: El diagrama UML es exactamente el mismo sin importar el lenguaje. En cada sección verás cómo se traduce directamente a Java, Python, C# y C++.
¿Qué es una clase?
Una clase es una representación o plantilla de un tipo de objeto dentro del sistema. En el modelado orientado a objetos y en UML, describe tres elementos fundamentales:
Usuario ← 1. Identidad (¿Qué es?)
- nombre: String
- email: String
← 2. Estado (¿Qué información tiene?)+ login(): boolean
+ logout(): void
← 3. Comportamiento (¿Qué puede hacer?)🏷️ 1. Identidad (Nombre)
El nombre de la clase permite identificar inequívocamente qué concepto del dominio representa en el sistema (ej. Usuario, Libro, Factura).
📊 2. Estado (Atributos)
Los atributos representan la información y valores que posee cada instancia (ej. nombre, email, saldo).
⚡ 3. Comportamiento (Métodos)
Los métodos u operaciones representan las acciones y funciones que la clase puede ejecutar (ej. login(), logout(), calcularTotal()).
✨ Fórmula fundamental:
Clase = Identidad + Estado + Comportamiento1. Descripción de la clase y los atributos
Un rectángulo UML con 3 compartimentos: nombre arriba, atributos al medio, métodos abajo. - privado, + público, # protegido.
UMLClase Libro — Atributos y Métodos
1public class Libro { // PascalCase
2 // - privado → private
3 private String titulo;
4 private String autor;
5 private int paginas;
6 private boolean prestado;
7
8 // UML: - titulo: String → private String titulo;
9}
1class Libro: # PascalCase
2 def __init__(self):
3 self._titulo = "" # _ indica "privado por convención"
4 self._autor = ""
5 self._paginas = 0
6 self._prestado = False
7
8 # atributos públicos en snake_case si no usas properties
9 # En Python no hay tipos obligatorios en el diagrama, pero los anotamos: titulo: str
1public class Libro { // PascalCase
2 private string titulo; // camelCase o _titulo
3 private string autor;
4 private int paginas;
5 private bool prestado;
6
7 // En C# solemos exponer con Properties (ver sección 3)
8}
1class Libro { // PascalCase
2private:
3 std::string titulo; // camelCase o titulo
4 std::string autor;
5 int paginas;
6 bool prestado;
7};
Regla UML:
- titulo: String = privado String titulo. Si ves + es público. El tipo va después de :.2. Constructor — con parámetro y sin parámetro
El constructor lleva el mismo nombre que la clase y no tiene tipo de retorno. Permite crear el objeto ya inicializado. Sobrecarga = dos constructores con distinta firma.
UMLSobrecarga de Constructores
1public class Libro {
2 private String titulo;
3 private String autor;
4
5 public Libro() { // sin parámetros
6 this.titulo = "Sin título";
7 this.autor = "Anónimo";
8 }
9 public Libro(String titulo, String autor) { // con parámetros
10 this.titulo = titulo;
11 this.autor = autor;
12 }
13 public Libro(String titulo, int paginas) { // sobrecarga distinta
14 this.titulo = titulo;
15 this.paginas = paginas;
16 }
17}
18Libro l1 = new Libro();
19Libro l2 = new Libro("Cien años", "García Márquez");
1class Libro:
2 def __init__(self, titulo="", autor="", paginas=0):
3 # Python no sobrecarga: un solo __init__ con valores por defecto
4 self._titulo = titulo
5 self._autor = autor
6 self._paginas = paginas
7
8# sin parámetros → usa defaults
9l1 = Libro()
10# con parámetros
11l2 = Libro("Cien años", "García Márquez", 471)
1public class Libro {
2 private string titulo;
3 private string autor;
4
5 public Libro() {
6 titulo = "Sin título";
7 autor = "Anónimo";
8 }
9 public Libro(string titulo, string autor) {
10 this.titulo = titulo;
11 this.autor = autor;
12 }
13 // C# también permite constructor con this() para encadenar
14 public Libro(string titulo, int paginas) : this() {
15 this.titulo = titulo;
16 this.paginas = paginas;
17 }
18}
1class Libro {
2private:
3 std::string titulo;
4 std::string autor;
5public:
6 Libro() : titulo("Sin título"), autor("Anónimo") {} // sin params, lista inicializadora
7 Libro(std::string t, std::string a) : titulo(t), autor(a) {} // con params
8 Libro(std::string t, int p) : titulo(t), paginas(p) {}
9private:
10 int paginas;
11};
⭐ En UML el constructor se reconoce porque se llama igual que la clase y no muestra retorno. Si hay dos, es sobrecarga.
3. Setters and Getters — encapsulamiento
Atributos private + métodos getTitulo()/setTitulo() para controlar acceso y validación. En el diagrama: + getTitulo(): String y + setTitulo(t:String): void. Excepción Java: si el atributo es boolean, el getter se llama isPrestado() no getPrestado() (JavaBeans).
UMLEncapsulamiento — Getters y Setters
1public class Libro {
2 private String titulo;
3 private int paginas;
4 private boolean prestado; // boolean → getter con 'is'
5
6 public String getTitulo() { // getter String/int → get
7 return titulo;
8 }
9 public void setTitulo(String titulo) { // setter con validación
10 if (titulo == null || titulo.isBlank()) throw new IllegalArgumentException();
11 this.titulo = titulo;
12 }
13 public int getPaginas() { return paginas; }
14 public void setPaginas(int paginas) {
15 if (paginas < 0) throw new IllegalArgumentException();
16 this.paginas = paginas;
17 }
18 // ¡Boolean usa 'is' en Java!
19 public boolean isPrestado() { // no getPrestado()
20 return prestado;
21 }
22 public void setPrestado(boolean prestado) {
23 this.prestado = prestado;
24 }
25}
1class Libro:
2 def __init__(self):
3 self._titulo = ""
4
5 @property
6 def titulo(self): # getter → libro.titulo
7 return self._titulo
8
9 @titulo.setter
10 def titulo(self, valor): # setter → libro.titulo = "X"
11 if not valor:
12 raise ValueError("título vacío")
13 self._titulo = valor
14
15l = Libro()
16l.titulo = "Rayuela" # usa setter
17print(l.titulo) # usa getter
1public class Libro {
2 private string titulo;
3 // Property → reemplaza getter/setter de Java
4 public string Titulo {
5 get => titulo;
6 set {
7 if (string.IsNullOrWhiteSpace(value)) throw new ArgumentException();
8 titulo = value;
9 }
10 }
11 // Auto-property corta:
12 public int Paginas { get; set; }
13}
1class Libro {
2private:
3 std::string titulo;
4 int paginas;
5 bool prestado;
6public:
7 std::string getTitulo() const { return titulo; }
8 void setTitulo(const std::string& t) {
9 if (t.empty()) throw std::invalid_argument("vacío");
10 titulo = t;
11 }
12 int getPaginas() const { return paginas; }
13 void setPaginas(int p) { paginas = p; }
14 bool isPrestado() const { return prestado; } // en C++ también común is*
15 void setPrestado(bool p) { prestado = p; }
16};
☕ Java tip — boolean:
isPrestado() no getPrestado(). private boolean prestado; → isPrestado() / setPrestado(). Frameworks (Spring, Jackson) lo esperan así.4. Métodos de clase personalizados
Más allá de getters/setters, la clase expone comportamiento: prestar(), devolver(), estaDisponible().
UMLMétodos Personalizados
1public class Libro {
2 private boolean prestado;
3
4 public void prestar() { // camelCase
5 if (prestado) throw new IllegalStateException("Ya prestado");
6 prestado = true;
7 }
8 public void devolver() { prestado = false; }
9 public boolean estaDisponible() { return !prestado; }
10 public String descripcion() { return "Libro prestado=" + prestado; }
11}
1class Libro:
2 def __init__(self):
3 self._prestado = False
4
5 def prestar(self): # snake_case
6 if self._prestado:
7 raise Exception("Ya prestado")
8 self._prestado = True
9
10 def devolver(self):
11 self._prestado = False
12
13 def esta_disponible(self) -> bool:
14 return not self._prestado
15
16 def descripcion(self) -> str:
17 return f"Libro prestado={self._prestado}"
1public class Libro {
2 private bool prestado;
3 public void Prestar() { // PascalCase en C#
4 if (prestado) throw new InvalidOperationException();
5 prestado = true;
6 }
7 public void Devolver() => prestado = false;
8 public bool EstaDisponible() => !prestado;
9 public string Descripcion() => $"Libro prestado={prestado}";
10}
1class Libro {
2private:
3 bool prestado = false;
4public:
5 void prestar() {
6 if (prestado) throw std::logic_error("Ya prestado");
7 prestado = true;
8 }
9 void devolver() { prestado = false; }
10 bool estaDisponible() const { return !prestado; }
11 std::string descripcion() const { return prestado ? "prestado" : "disponible"; }
12};
5. Override — reescribir el comportamiento
Una subclase reescribe un método heredado para especializarlo. En UML se ve el mismo método en padre e hija; en código lleva anotación.
UMLOverride y Polimorfismo
1public class Publicacion {
2 protected String titulo;
3 public Publicacion(String titulo) { this.titulo = titulo; }
4 public String mostrar() { return "Publicación: " + titulo; }
5}
6public class Libro extends Publicacion {
7 private int paginas;
8 public Libro(String titulo, int paginas) {
9 super(titulo); this.paginas = paginas;
10 }
11 @Override // obligatorio para override
12 public String mostrar() {
13 return "Libro: " + titulo + " (" + paginas + " pág.)";
14 }
15}
1class Publicacion:
2 def __init__(self, titulo):
3 self.titulo = titulo
4 def mostrar(self) -> str: # método base
5 return f"Publicación: {self.titulo}"
6
7class Libro(Publicacion): # hereda
8 def __init__(self, titulo, paginas):
9 super().__init__(titulo)
10 self.paginas = paginas
11 def mostrar(self) -> str: # override (mismo nombre)
12 return f"Libro: {self.titulo} ({self.paginas} pág.)"
13
14print(Libro("Rayuela", 300).mostrar())
1public class Publicacion {
2 protected string titulo;
3 public Publicacion(string titulo) => this.titulo = titulo;
4 public virtual string Mostrar() => $"Publicación: {titulo}"; // virtual
5}
6public class Libro : Publicacion {
7 private int paginas;
8 public Libro(string t, int p) : base(t) => paginas = p;
9 public override string Mostrar() => $"Libro: {titulo} ({paginas} pág.)"; // override
10}
1class Publicacion {
2protected:
3 std::string titulo;
4public:
5 Publicacion(std::string t) : titulo(t) {}
6 virtual std::string mostrar() const { // virtual
7 return "Publicación: " + titulo;
8 }
9 virtual ~Publicacion() = default;
10};
11class Libro : public Publicacion {
12 int paginas;
13public:
14 Libro(std::string t, int p) : Publicacion(t), paginas(p) {}
15 std::string mostrar() const override { // override
16 return "Libro: " + titulo + " (" + std::to_string(paginas) + " pág.)";
17 }
18};
⭐
super() / super.mostrar() llama al padre. @Override en Java y override en C++/C# evitan errores si cambias la firma.6. Conexiones — asociación y composición
Las clases rara vez viven solas. Una clase usa otra como atributo:
- Asociación (◇—): una clase tiene otra pero no la posee.
LibrotieneEtiqueta→ si borro el libro, las etiquetas pueden seguir vivas. - Composición (◆—): una clase posee completamente a otra.
LibrocomponeAutor→ si borro el libro, su referencia al autor se destruye también.
En UML: diamante vacío (◇) = asociación débil, diamante lleno (◆) = composición fuerte.
UMLRelaciones — Asociación y Composición
1import java.util.ArrayList;
2import java.util.List;
3
4public class Libro {
5 private String titulo;
6 private Autor autor; // composición: un autor por libro
7 private List<Etiqueta> etiquetas; // asociación: muchas etiquetas
8
9 public Libro(String titulo, Autor autor) {
10 this.titulo = titulo;
11 this.autor = autor;
12 this.etiquetas = new ArrayList<>();
13 }
14 public Autor getAutor() { return autor; }
15 public void addEtiqueta(Etiqueta e) { etiquetas.add(e); }
16}
17Libro l = new Libro("Rayuela", new Autor("Cortázar"));
18l.addEtiqueta(new Etiqueta("novela"))
1class Autor:
2 def __init__(self, nombre):
3 self.nombre = nombre
4
5class Etiqueta:
6 def __init__(self, nombre):
7 self.nombre = nombre
8
9class Libro:
10 def __init__(self, titulo, autor):
11 self.titulo = titulo
12 self.autor = autor # composición: autor vive con el libro
13 self.etiquetas = [] # asociación: lista de etiquetas
14
15 def add_etiqueta(self, etiqueta):
16 self.etiquetas.append(etiqueta)
17
18a = Autor("García Márquez")
19l = Libro("Cien años", a)
20l.add_etiqueta(Etiqueta("realismo"))
1public class Libro {
2 private string titulo;
3 private Autor autor; // composición
4 private List<Etiqueta> etiquetas; // asociación
5
6 public Libro(string titulo, Autor autor) {
7 this.titulo = titulo;
8 this.autor = autor;
9 this.etiquetas = new List<Etiqueta>();
10 }
11 public Autor Autor => autor;
12 public void AddEtiqueta(Etiqueta e) => etiquetas.Add(e);
13}
14var l = new Libro("Rayuela", new Autor("Cortázar"));
15l.AddEtiqueta(new Etiqueta("novela"))
1#include <vector>
2#include <string>
3
4class Autor {
5public:
6 std::string nombre;
7 Autor(std::string n) : nombre(n) {}
8};
9
10class Etiqueta {
11public:
12 std::string nombre;
13 Etiqueta(std::string n) : nombre(n) {}
14};
15
16class Libro {
17 std::string titulo;
18 Autor autor; // composición (por valor)
19 std::vector<Etiqueta> etiquetas; // asociación (vector)
20public:
21 Libro(std::string t, Autor a) : titulo(t), autor(a) {}
22 Autor getAutor() const { return autor; }
23 void addEtiqueta(Etiqueta e) { etiquetas.push_back(e); }
24};
⭐ En UML la línea con diamante va del contenedor al contenido. Diamante vacío (◇) = asociación (etiquetas sobreviven). Diamante lleno (◆) = composición (el contenido muere con el contenedor). El número junto a la línea indica cardinalidad:
1, 0..*, 1..*.7. Herencia — class Libro extends Publicacion
La herencia permite reutilizar código: la subclase hereda atributos y métodos del padre y puede añadir los suyos o reescribirlos.
En UML: triángulo vacío (▽) apunta del hijo al padre. Relación"es-un": Libro es una Publicacion.
UMLJerarquía de Herencia — Publicación
1public class Publicacion {
2 protected String titulo;
3 protected String isbn;
4 public Publicacion(String titulo, String isbn) {
5 this.titulo = titulo;
6 this.isbn = isbn;
7 }
8 public String getTitulo() { return titulo; }
9 public String descripcion() { return "Publicación: " + titulo; }
10}
11
12public class Libro extends Publicacion {
13 private int paginas;
14 public Libro(String titulo, String isbn, int paginas) {
15 super(titulo, isbn);
16 this.paginas = paginas;
17 }
18 public int getPaginas() { return paginas; }
19 @Override
20 public String descripcion() {
21 return "Libro: " + titulo + " (" + paginas + " pág.)";
22 }
23}
24
25public class Revista extends Publicacion {
26 private int numero;
27 private String frecuencia;
28 public Revista(String titulo, String isbn, int numero, String frecuencia) {
29 super(titulo, isbn);
30 this.numero = numero;
31 this.frecuencia = frecuencia;
32 }
33 public int getNumero() { return numero; }
34 @Override
35 public String descripcion() {
36 return "Revista #" + numero + " (" + frecuencia + ")";
37 }
38}
1class Publicacion:
2 def __init__(self, titulo, isbn):
3 self.titulo = titulo
4 self.isbn = isbn
5 def descripcion(self):
6 return f"Publicación: {self.titulo}"
7
8class Libro(Publicacion): # hereda de Publicacion
9 def __init__(self, titulo, isbn, paginas):
10 super().__init__(titulo, isbn) # llama al padre
11 self.paginas = paginas
12 def descripcion(self): # override
13 return f"Libro: {self.titulo} ({self.paginas} pág.)"
14
15class Revista(Publicacion):
16 def __init__(self, titulo, isbn, numero, frecuencia):
17 super().__init__(titulo, isbn)
18 self.numero = numero
19 self.frecuencia = frecuencia
20 def descripcion(self): # override
21 return f"Revista #{self.numero} ({self.frecuencia})"
22
23class EBook(Publicacion):
24 def __init__(self, titulo, isbn, tamano_mb):
25 super().__init__(titulo, isbn)
26 self.tamano_mb = tamano_mb
27 def descripcion(self): # override
28 return f"EBook: {self.titulo} ({self.tamano_mb} MB)"
1public class Publicacion {
2 protected string titulo;
3 protected string isbn;
4 public Publicacion(string titulo, string isbn) {
5 this.titulo = titulo;
6 this.isbn = isbn;
7 }
8 public string Titulo => titulo;
9 public virtual string Descripcion() => $"Publicación: {titulo}";
10}
11
12public class Libro : Publicacion {
13 private int paginas;
14 public Libro(string t, string isbn, int p) : base(t, isbn) => paginas = p;
15 public int Paginas => paginas;
16 public override string Descripcion() => $"Libro: {titulo} ({paginas} pág.)";
17}
18
19public class Revista : Publicacion {
20 private int numero;
21 private string frecuencia;
22 public Revista(string t, string isbn, int n, string f) : base(t, isbn) {
23 numero = n;
24 frecuencia = f;
25 }
26 public override string Descripcion() => $"Revista #{numero} ({frecuencia})";
27}
1class Publicacion {
2protected:
3 std::string titulo;
4 std::string isbn;
5public:
6 Publicacion(std::string t, std::string i) : titulo(t), isbn(i) {}
7 std::string getTitulo() const { return titulo; }
8 virtual std::string descripcion() const {
9 return "Publicación: " + titulo;
10 }
11 virtual ~Publicacion() = default;
12};
13
14class Libro : public Publicacion {
15 int paginas;
16public:
17 Libro(std::string t, std::string i, int p)
18 : Publicacion(t, i), paginas(p) {}
19 int getPaginas() const { return paginas; }
20 std::string descripcion() const override {
21 return "Libro: " + titulo + " (" + std::to_string(paginas) + " pág.)";
22 }
23};
24
25class Revista : public Publicacion {
26 int numero;
27 std::string frecuencia;
28public:
29 Revista(std::string t, std::string i, int n, std::string f)
30 : Publicacion(t, i), numero(n), frecuencia(f) {}
31 std::string descripcion() const override {
32 return "Revista #" + std::to_string(numero) + " (" + frecuencia + ")";
33 }
34};
Herencia vs Composición: Usa herencia cuando la relación es "es-un" (Libro es Publicación). Usa composición cuando es "tiene-un" (Libro tiene Autor). Preferir composición sobre herencia cuando sea posible.
8. Interfaces — implements Imprimible
Una interfaz es un contrato: define qué métodos debe tener una clase pero no cómo se implementan. Una clase puede implementar múltiples interfaces (a diferencia de heredar de un solo padre).
En UML: se escribe <<interface>> en la cabecera y la flecha es línea punteada con triángulo (▽LineStyle::dashed).
UMLInterfaces y Contratos
1public interface Imprimible {
2 String imprimir(); // todas las clases que implementen DEBEN tener imprimir()
3}
4
5public class Libro implements Imprimible {
6 private String titulo;
7 public Libro(String titulo) { this.titulo = titulo; }
8 @Override
9 public String imprimir() { return "Libro: " + titulo; }
10}
11
12public class Revista implements Imprimible {
13 private int numero;
14 public Revista(int numero) { this.numero = numero; }
15 @Override
16 public String imprimir() { return "Revista #" + numero; }
17}
18
19public class Recibo implements Imprimible {
20 private double monto;
21 public Recibo(double monto) { this.monto = monto; }
22 @Override
23 public String imprimir() { return "Recibo: $" + monto; }
24}
25
26// Polimorfismo
27Imprimible[] docs = { new Libro("Rayuela"), new Revista(42), new Recibo(2500) };
28for (Imprimible d : docs) {
29 System.out.println(d.imprimir());
30}
1from abc import ABC, abstractmethod
2
3class Imprimible(ABC): # clase abstracta = interfaz
4 @abstractmethod
5 def imprimir(self) -> str:
6 pass
7
8class Libro(Imprimible):
9 def __init__(self, titulo):
10 self.titulo = titulo
11 def imprimir(self) -> str: # implementa el contrato
12 return f"Libro: {self.titulo}"
13
14class Revista(Imprimible):
15 def __init__(self, numero):
16 self.numero = numero
17 def imprimir(self) -> str:
18 return f"Revista #{self.numero}"
19
20class Recibo(Imprimible):
21 def __init__(self, monto):
22 self.monto = monto
23 def imprimir(self) -> str:
24 return "Recibo: $" + str(self.monto)
25
26# Polimorfismo: todas se tratan como Imprimible
27docs = [Libro("Rayuela"), Revista(42), Recibo(2500)]
28for d in docs:
29 print(d.imprimir())
1public interface Imprimible {
2 string Imprimir(); // contrato
3}
4
5public class Libro : Imprimible {
6 private string titulo;
7 public Libro(string titulo) => this.titulo = titulo;
8 public string Imprimir() => $"Libro: {titulo}";
9}
10
11public class Revista : Imprimible {
12 private int numero;
13 public Revista(int numero) => this.numero = numero;
14 public string Imprimir() => $"Revista #{numero}";
15}
16
17public class Recibo : Imprimible {
18 private double monto;
19 public Recibo(double monto) => this.monto = monto;
20 public string Imprimir() => "Recibo: $" + monto;
21}
22
23// Polimorfismo
24Imprimible[] docs = { new Libro("Rayuela"), new Revista(42), new Recibo(2500) };
25foreach (var d in docs) Console.WriteLine(d.Imprimir());
1class Imprimible { // interfaz = clase con solo métodos virtuales puros
2public:
3 virtual std::string imprimir() const = 0; // = 0 → pura
4 virtual ~Imprimible() = default;
5};
6
7class Libro : public Imprimible {
8 std::string titulo;
9public:
10 Libro(std::string t) : titulo(t) {}
11 std::string imprimir() const override {
12 return "Libro: " + titulo;
13 }
14};
15
16class Revista : public Imprimible {
17 int numero;
18public:
19 Revista(int n) : numero(n) {}
20 std::string imprimir() const override {
21 return "Revista #" + std::to_string(numero);
22 }
23};
24
25class Recibo : public Imprimible {
26 double monto;
27public:
28 Recibo(double m) : monto(m) {}
29 std::string imprimir() const override {
30 return "Recibo: $" + std::to_string(monto);
31 }
32};
33
34// Polimorfismo
35#include <vector>
36#include <memory>
37std::vector<std::unique_ptr<Imprimible>> docs;
38docs.push_back(std::make_unique<Libro>("Rayuela"));
39docs.push_back(std::make_unique<Revista>(42));
40docs.push_back(std::make_unique<Recibo>(2500));
41for (const auto& d : docs) {
42 std::cout << d->imprimir() << std::endl;
43}
Herencia vs Interface: Herencia = "es-un" (un tipo). Interface = "puede-hacer" (un comportamiento). Java/C# permiten heredar de un solo padre pero implementarmúltiples interfaces. Ej:
class Libro extends Publicacion implements Imprimible, Serializable.Resumen — Los 4 pilares de las Clases
1. Clase
Atributos + métodos + constructores + getters/setters
Atributos + métodos + constructores + getters/setters
2. Conexiones
Asociación (◇) y Composición (◆)
Asociación (◇) y Composición (◆)
3. Herencia
extends — relación "es-un"4. Interfaces
implements — contrato "puede-hacer"Practica con los desafíos: Herencia e Interfaces.
🧱 Reto: Modela tu Libro completo
Crea una clase Libro con atributos titulo, autor, paginas, prestado, dos constructores (vacío y con titulo/autor), getters/setters con validación, métodos prestar()/devolver() y una subclase LibroDigital que haga override de mostrar().
👁️ Ver esquema UML esperado
UMLReto: Modelo Completo de Libro
Implementa en el lenguaje del selector y compara.
