name: portada
class: portada-slide, center, middle

# Classes abstractes i interfícies

.footnote[Mateu Yábar Valles]

---
<h3 class="alert-heading">Llicència</h3>
<p>Pots copiar i redistribuir aquest material seguint la llicència Attribution-NonCommercial-ShareAlike 4.0 International <a href="https://creativecommons.org/licenses/by-nc-sa/4.0/">CC BY-NC-SA 4.0</a>, indicant-ne autors originals, l'origen (aquesta web), sense fins comercials i mantenint-ne aquesta la llicència</p>
<p class="mb-0">Autors:</p>
<ul><li><a href="https://fp.mateuyabar.com">Mateu</a></li><li><a href="https://centellas.gitlab.io/teachingSite">Laura Centellas</a></li></ul>

---
<!--
mirar EXEMLE (https://stackoverflow.com/questions/26444145/extend-data-class-in-kotlin)

abstract class Resource {
    abstract var id: Long
    abstract var location: String
}

data class Book (
    override var id: Long = 0,
    override var location: String = "",
    var isbn: String
) : Resource()

# Exercici
- ListOfFigurePainter -->

# Classe abstracte
- En una relació d'herència entre classes, per tal d'evitar que una classe __generalitzadora__ pugui ser instanciada direm que és una __classe abstracte__
- És una classe que __No__ es pot instanciar

```
abstract class ClasseAbstracte{
  val atribut: Int = 0
  abstract val atributAbstracte: Int

abstract fun metodeAbstracte()

fun metodeNoAbstracte() {
        // Implementació TODO
    }
}
```

---
# Subclasse d'una classe abstracte
- Les classes (no abstractes) que deriven d'una classe abstracte han d'implementar tots els mètodes abtractes de la classe pare.
- Fent ús de la paraula clau __override__
```kotlin
  class Subclase : ClaseAbstracta() {
    override val atributAbstracte: Int = 10

override fun metodeAbstracte() {
      println(atributAbstracte)
    }
  }
```
- Les classes abstractes permeten l'__herència__ sense ser open
---
# Exemple 1
```
abstract sealed class Figure(val color: Color){
  abstract fun paint()
  // ...
}
```
```
abstract sealed class SomeClass{
  abstract val name: String
}
```
---

# Exemple 2
```
abstract class Attack {
    val baseDamage: Int = 10

abstract fun execute(): String
}

class Headbutt : Attack() {
    override fun execute(): String {
        return "Cop de cap! ${baseDamage + 1}"
    }
}

class Kick : Attack() {
    override fun execute(): String {
        return "Patada! ${baseDamage + 2}"
    }
}

class Fireball : Attack() {
    override fun execute(): String {
        return "Bola de foc! ${baseDamage + 3}"
    }
}
```
---
# Data classes i herència

```
abstract class Resource {
    abstract var id: Long
    abstract var location: String
}

data class Book (
    override var id: Long = 0,
    override var location: String = "",
    var isbn: String
) : Resource()
```
---
# Interfície
- Permeten que diferents classes no relacionades puguin tenir el mateix __comportament__.
- Són com contractes que __especifiquen__ les operacions, però no les __implementen__. Les classes que implementen una interfície en defineixen les operacions.
- keywords: 
  - __interface__ - enlloc de classe
  - __override__ - per implementar els atributs i mètodes abstractes

---
# Exemple
- Interfície
  - List
```
val list1 : List<String> = ArrayList<String>()
val list2 : List<String> = LinkedList<String>()
```

---
# Interfície

```
interface Interficie1 {
    val atributAbstracte : Int 
    val atribut : Boolean get() = p1 > 0

fun metodeAbstracte()

fun metode() { print("Mètode implementat")}
}
```

```
class Exemple : Interficie1, Interficie2 {
    override val atributAbstracte: Int = 0

override fun metodeAbstracte() {
        print("mètode de la interfície sobreescrit!")
    }
}
```
---
# Exemple 1

```
interface BcnTreeDataSource {
    fun listTrees(): List<BcnTree>
}
```

```
class LocalBcnTreeDataSource():BcnTreeDataSource{
    override fun listTrees(): List<BcnTree> {
        TODO("Implement: Obtains trees from file")
    }
}
class APIBcnTreeDataSource():BcnTreeDataSource{
    override fun listTrees(): List<BcnTree> {
        TODO("Implement: Obtains trees from url")
    }
}
```
---
# Exemple - ús
```
fun main(){
    val USE_API = true
    val bcnTreeDataSource : BcnTreeDataSource = if(USE_API) APIBcnTreeDataSource() else LocalBcnTreeDataSource()
    val trees = bcnTreeDataSource.listTrees()
    println(trees.count())
}
```
---
# Exemple 2
```
interface Volador {
    fun enlairar()
    fun volar()
}
interface Carregador{
    fun carregarPassatgers(passatger:Person)
    fun carregarEquipatge(equipatge:Equipatge)
}
class Avio : Volador, Carregador {
    override fun enlairar() { println("Cap amunt!") }
    override fun volar() { TODO("Not yet implemented") }
    override fun carregarPassatgers(passatger: Person) { TODO("Not yet implemented") }
    override fun carregarEquipatge(equipatge: Equipatge) { TODO("Not yet implemented") }
}
class Anec (var race : String) : Volador{ // TODO}
class Person (var name : String, var age : Int): Carregador { //TODO}
```
---
# Interfície comparable
- [comparable](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-comparable/)
- Defineix classes que es poden comparar
  - Permet definir algoritmes d'ordenació genèrics

```
public interface Comparable<in T> {
    public operator fun compareTo(other: T): Int
}
 
class MyModel : Comparable<MyModel>{
  override fun compareTo(other: MyModel): Int { //TODO}
}

fun main(){
  List<MyModel> list = mutableListof<MyModel>();
  list.sort();
}
```
---
# Exemple 1

```
data class BcnTree(val name : String) : Comparable<BcnTree>{
    override fun compareTo(other: BcnTree) = name.compareTo(other.name)
}
```

```
list.sort()
```
---
# Rectangle implementa Comparable
```
data class Rectangle(var length: Int, var width: Int) : Comparable<Rectangle> {
    val area get() = length * width
    override fun compareTo(other: Rectangle): Int {
        var bigger = 0
        if (this.area > other.area) bigger = 1
        else if (this.area < other.area) bigger = -1
        return bigger
    }
}

fun main() {
    var list = mutableListOf<Rectangle>(Rectangle(23, 4), Rectangle(3, 5), Rectangle(23, 4))
    println(list.sort())
}
/* [Rectangle(length=3, width=5), Rectangle(length=23, width=4), Rectangle(length=23, width=4)] */
```
---
# Functional SAM Interfaces
- Una interficie que només té un mètode abstracte és una __functional interface__, o __Single Abstract Method (SAM) interface__.

```
public expect fun interface Comparator<T> {
    public fun compare(a: T, b: T): Int
}
```
```
fun <T> MutableList<T>.sortWith(comparator: Comparator<in T>)
```
```
fun main() {
    var values = mutableListOf<Rectangle>(Rectangle(23, 4), Rectangle(3, 5), Rectangle(23, 4))
    values.sortWith(object : Comparator<Rectangle> {
        override fun compare(x: Rectangle, y: Rectangle) = x.width - y.width
    })
    values.sortWith{a,b -> a.width - b.width} 
}
```
---
# Bibliografia 
- https://www.develou.com/clases-abstractas-en-kotlin/