Skip to content

Commit d5ae690

Browse files
Roswell468Roswell468
authored
Merge pull request mouredev#6001 from eulogioep/main
#26 y 27 Kotlin
2 parents 2fa8405 + eaacbda commit d5ae690

File tree

2 files changed

+206
-0
lines changed

2 files changed

+206
-0
lines changed

‎Roadmap/26 - SOLID SRP/kotlin/eulogioep.kt‎

Lines changed: 130 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,130 @@
1+
/*
2+
* Principio de Responsabilidad Única (SRP)
3+
*
4+
* El Principio de Responsabilidad Única es el primer principio de SOLID y establece que una clase
5+
* debe tener una, y solo una, razón para cambiar. En otras palabras, una clase debe tener una
6+
* única responsabilidad bien definida.
7+
*
8+
* Este principio promueve la modularidad, facilita el mantenimiento y mejora la legibilidad del código.
9+
* Cuando una clase tiene múltiples responsabilidades, se vuelve más difícil de entender, modificar y probar.
10+
*/
11+
12+
// Definiciones de datos comunes
13+
data class Book(val title: String, val author: String, var availableCopies: Int)
14+
data class User(val name: String, val id: String, val email: String)
15+
data class Loan(val user: User, val book: Book)
16+
17+
// Versión que no cumple con SRP
18+
class LibraryWithoutSRP {
19+
private val books = mutableListOf<Book>()
20+
private val users = mutableListOf<User>()
21+
private val loans = mutableListOf<Loan>()
22+
23+
fun addBook(title: String, author: String, copies: Int) {
24+
books.add(Book(title, author, copies))
25+
}
26+
27+
fun registerUser(name: String, id: String, email: String) {
28+
users.add(User(name, id, email))
29+
}
30+
31+
fun loanBook(userId: String, bookTitle: String) {
32+
val user = users.find { it.id == userId }
33+
val book = books.find { it.title == bookTitle }
34+
if (user != null && book != null && book.availableCopies > 0) {
35+
loans.add(Loan(user, book))
36+
book.availableCopies--
37+
}
38+
}
39+
40+
fun returnBook(userId: String, bookTitle: String) {
41+
val loan = loans.find { it.user.id == userId && it.book.title == bookTitle }
42+
if (loan != null) {
43+
loans.remove(loan)
44+
loan.book.availableCopies++
45+
}
46+
}
47+
}
48+
49+
// Versión refactorizada que cumple con SRP
50+
class BookManager {
51+
private val books = mutableListOf<Book>()
52+
53+
fun addBook(title: String, author: String, copies: Int) {
54+
books.add(Book(title, author, copies))
55+
}
56+
57+
fun findBook(title: String): Book? = books.find { it.title == title }
58+
}
59+
60+
class UserManager {
61+
private val users = mutableListOf<User>()
62+
63+
fun registerUser(name: String, id: String, email: String) {
64+
users.add(User(name, id, email))
65+
}
66+
67+
fun findUser(id: String): User? = users.find { it.id == id }
68+
}
69+
70+
class LoanManager {
71+
private val loans = mutableListOf<Loan>()
72+
73+
fun loanBook(user: User, book: Book) {
74+
if (book.availableCopies > 0) {
75+
loans.add(Loan(user, book))
76+
book.availableCopies--
77+
}
78+
}
79+
80+
fun returnBook(user: User, book: Book) {
81+
val loan = loans.find { it.user == user && it.book == book }
82+
if (loan != null) {
83+
loans.remove(loan)
84+
book.availableCopies++
85+
}
86+
}
87+
}
88+
89+
class Library(
90+
private val bookManager: BookManager,
91+
private val userManager: UserManager,
92+
private val loanManager: LoanManager
93+
) {
94+
fun addBook(title: String, author: String, copies: Int) {
95+
bookManager.addBook(title, author, copies)
96+
}
97+
98+
fun registerUser(name: String, id: String, email: String) {
99+
userManager.registerUser(name, id, email)
100+
}
101+
102+
fun loanBook(userId: String, bookTitle: String) {
103+
val user = userManager.findUser(userId)
104+
val book = bookManager.findBook(bookTitle)
105+
if (user != null && book != null) {
106+
loanManager.loanBook(user, book)
107+
}
108+
}
109+
110+
fun returnBook(userId: String, bookTitle: String) {
111+
val user = userManager.findUser(userId)
112+
val book = bookManager.findBook(bookTitle)
113+
if (user != null && book != null) {
114+
loanManager.returnBook(user, book)
115+
}
116+
}
117+
}
118+
119+
// Uso del sistema refactorizado
120+
fun main() {
121+
val bookManager = BookManager()
122+
val userManager = UserManager()
123+
val loanManager = LoanManager()
124+
val library = Library(bookManager, userManager, loanManager)
125+
126+
library.addBook("1984", "George Orwell", 5)
127+
library.registerUser("EulogioEP", "001", "eulogioep@email.com")
128+
library.loanBook("001", "1984")
129+
library.returnBook("001", "1984")
130+
}

‎Roadmap/27 - SOLID OCP/kotlin/eulogioep.kt‎

Lines changed: 76 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,76 @@
1+
/*
2+
* Principio Abierto-Cerrado (OCP) de SOLID
3+
*
4+
* El principio OCP establece que las entidades de software (clases, módulos, funciones, etc.)
5+
* deben estar abiertas para la extensión, pero cerradas para la modificación. Esto significa
6+
* que debemos poder extender el comportamiento de una clase sin modificar su código existente.
7+
*
8+
* En este ejemplo, demostraremos cómo aplicar el OCP en el diseño de una calculadora,
9+
* permitiendo agregar nuevas operaciones sin modificar el código existente.
10+
*/
11+
12+
// Interfaz que define la operación matemática
13+
interface Operation {
14+
fun execute(a: Double, b: Double): Double
15+
}
16+
17+
// Implementaciones de las operaciones básicas
18+
class Addition : Operation {
19+
override fun execute(a: Double, b: Double) = a + b
20+
}
21+
22+
class Subtraction : Operation {
23+
override fun execute(a: Double, b: Double) = a - b
24+
}
25+
26+
class Multiplication : Operation {
27+
override fun execute(a: Double, b: Double) = a * b
28+
}
29+
30+
class Division : Operation {
31+
override fun execute(a: Double, b: Double): Double {
32+
if (b == 0.0) throw IllegalArgumentException("Cannot divide by zero")
33+
return a / b
34+
}
35+
}
36+
37+
// Calculadora que utiliza el principio OCP
38+
class Calculator {
39+
private val operations = mutableMapOf<String, Operation>()
40+
41+
fun addOperation(name: String, operation: Operation) {
42+
operations[name] = operation
43+
}
44+
45+
fun calculate(a: Double, b: Double, operationName: String): Double {
46+
val operation = operations[operationName]
47+
?: throw IllegalArgumentException("Operation not supported")
48+
return operation.execute(a, b)
49+
}
50+
}
51+
52+
// Ejemplo de uso y prueba
53+
fun main() {
54+
val calculator = Calculator()
55+
56+
// Agregar operaciones básicas
57+
calculator.addOperation("add", Addition())
58+
calculator.addOperation("subtract", Subtraction())
59+
calculator.addOperation("multiply", Multiplication())
60+
calculator.addOperation("divide", Division())
61+
62+
// Probar operaciones básicas
63+
println("5 + 3 = ${calculator.calculate(5.0, 3.0, "add")}")
64+
println("5 - 3 = ${calculator.calculate(5.0, 3.0, "subtract")}")
65+
println("5 * 3 = ${calculator.calculate(5.0, 3.0, "multiply")}")
66+
println("6 / 3 = ${calculator.calculate(6.0, 3.0, "divide")}")
67+
68+
// Agregar una nueva operación (potencia) sin modificar el código existente
69+
class Power : Operation {
70+
override fun execute(a: Double, b: Double) = Math.pow(a, b)
71+
}
72+
calculator.addOperation("power", Power())
73+
74+
// Probar la nueva operación
75+
println("2^3 = ${calculator.calculate(2.0, 3.0, "power")}")
76+
}

0 commit comments

Comments
 (0)