Abstractes i interfícies

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

# Abstractes i interfícies

.footnote[Joan Puigcerver Ibáñez]

---
layout: true
class: regular-slide
.right[.logo[![logoMislata](/itb/images/logo_mislata.png)]]

---
# Exercici
- ListOfFigurePainter

---
# Classe abstracta
- Pot tenir mètodes abstractes
  - Només té la capçalera.
- No es pot instanciar

```
public abtract class Figure {
  // ...
  public abstract void paint(PrintStream printStream);
}
```

---
# Filla de classe abtracte
- Una classe filla no abtracta ha d'implementar tots els mètodes abtractes de la pare

---
# Interficie
- Defineix un conjunt de mètodes
- No té implementació
- Una classe pot implementar més d'una interfície
- Separa la definició de la implementació
  - Desacoplament

---
# Exemples
- Interfície
  - List
- Implementació
  - ArrayList
  - LinkedList
  - ...

---
# Interficie

```
public interface PlantWater{
  public List<double> getHumidityRecord();
  public void startWatterSystem();
}
```

```
public class PlantWaterDevice implements PlantWater{
  
}
```

---
# Interficie - us

```
public class PlantWaterControler
  PlantWater plantWater;
  public PlantWaterControler(PlantWater plantWater){
    this.plantWater = plantWater;
  }
  public waterIfNeeded(){
    //...
  }
}
```

---
# Interfície comparable
- Defineix classes que es poden comparar
  - Permet definir algoritmes d'ordenació genèrics

```
int compareTo(T o);
```

```
public class MyModel implements Comparable<MyModel>{

}
```

```
List<MyModel> list = new ArrayList();
Collections.sort(list);
```

---
# Classes anònimes
- delcarar i instànciar una classe a l'hora

```
List<Rectangle> values = new ArrayList<>();
Comparator<Rectangle> comparator = new Comparator<Rectangle>() {
    @Override
    public int compare(Rectangle r1, Rectangle r2) {
        return Double.compare(r1.getArea(), r2.getArea());
    }
};
Collections.sort(values, comparator);
```

---
# Classes anònimes - Lambda
- Si la interfície només té una funció podem usar una lambda
  - Definició anònima de funcions

```
List<Rectangle> values = new ArrayList<>();
Comparator<Rectangle> comparator = (r1, r2) -> Double.compare(r1.getArea(), r2.getArea());
Collections.sort(values, comparator);
```

```
Collections.sort(values, (r1, r2)
                -> Double.compare(r1.getArea(), r2.getArea()));
```