<u>Diferencias entre </u>interface<u> y </u>abstract class
EmailRepository y NotifyEmailRepository<u>:</u>
👉 No almacena datos ni estado.
👉 Define un contrato puro, sin lógica.
👉 Cualquier clase (en memoria, SQLite, remota) puede implementarla de forma diferente.
class InMemoryEmailRepositoryImpl : EmailRepository
👉 Implementa la interface, proporcionando una implementación concreta en memoria.
👉 La lógica es 100% propia.
abstract class NotifyEmailRepositoryImpl(...) : NotifyEmailRepository
Es una abstract class con lógica común:
- Guarda el
emailRepositorycomo dependencia. - Implementa
notifyById(id)(método común). - Obliga a subclases a definir
notify(email)→ comportamiento específico.
💡 Esta clase es un template: resuelve lo repetido y fuerza a que cada implementación defina su variante.
NotifySentEmailRepositoryImpl y NotifyReceivedEmailRepositoryImpl
Son clases concretas, que hereda la lógica común de NotifyEmailRepositoryImpl
Solo definen qué imprimir cuando se notifica un envío.
👉 Siguen el patrón: reutilizar lógica de búsqueda y solo definir cómo se notifica.
import java.util.UUID
data class Emails(
val id: UUID,
val asunto: String,
val mensaje: String
)
// Interface
interface EmailRepository {
val sizeEmails: Int
fun save(email: Emails)
fun findById(id: UUID): Emails?
fun findAll(): List<Emails>
fun deleteById(id: UUID)
}
class InMemoryEmailRepositoryImpl : EmailRepository {
val repositoryName: String = "InMemoryEmailRepositoryImpl"
private val emails = mutableListOf<Emails>()
override val sizeEmails: Int
get() = emails.size
override fun save(email: Emails) {
emails.add(email)
}
override fun findById(id: UUID): Emails? {
return emails.find { it.id == id }
}
override fun findAll(): List<Emails> {
return emails
}
override fun deleteById(id: UUID) {
emails.removeIf { it.id == id }
}
}
// abstract
interface NotifyEmailRepository {
fun notifyById(id: UUID)
}
abstract class NotifyEmailRepositoryImpl(
private val emailRepository: EmailRepository
): NotifyEmailRepository {
/*
Se usa **final override** para evitar que subclases vuelvan a sobrescribir
ese método (notifyById). Así asegurás que la lógica de búsqueda no se modifique.
*/
final override fun notifyById(id: UUID) {
emailRepository.findById(id)?.let {
notify(it)
}
}
/*
protected: solo las subclases pueden usarla.
abstract: obliga a cada subclase a implementar cómo notificar.
Así, cada subclase solo define el println, pero no toca la lógica de búsqueda.
*/
protected abstract fun notify(email: Emails)
}
class NotifySentEmailRepositoryImpl(
repository: EmailRepository
): NotifyEmailRepositoryImpl(repository) {
override fun notify(email: Emails) {
println("Email enviado: ${email.asunto}")
}
}
class NotifyReceivedEmailRepositoryImpl(
repository: EmailRepository
): NotifyEmailRepositoryImpl(repository) {
override fun notify(email: Emails) {
println("Tienes un nuevo email: ${email.asunto}")
}
}
fun main() {
val emailRepository: EmailRepository = InMemoryEmailRepositoryImpl()
val notifySentEmailRepository: NotifyEmailRepository = NotifySentEmailRepositoryImpl(emailRepository)
val notifyReceivedEmailRepository: NotifyEmailRepository = NotifyReceivedEmailRepositoryImpl(emailRepository)
println(emailRepository.sizeEmails)
emailRepository.save(
Emails(
id = UUID.randomUUID(),
asunto = "Hola",
mensaje = "Que tal"
)
)
notifySentEmailRepository.notifyById(emailRepository.findAll()[0].id)
notifyReceivedEmailRepository.notifyById(emailRepository.findAll()[0].id)
emailRepository.save(
Emails(
id = UUID.randomUUID(),
asunto = "Hola 2",
mensaje = "Que tal 2"
)
)
notifySentEmailRepository.notifyById(emailRepository.findAll()[1].id)
notifyReceivedEmailRepository.notifyById(emailRepository.findAll()[1].id)
println(emailRepository.sizeEmails)
println(emailRepository.findAll())
println(emailRepository.findById(emailRepository.findAll()[0].id))
emailRepository.deleteById(emailRepository.findAll()[0].id)
println(emailRepository.findAll())
}


Mi aporte a la resolucion del ejercicio: