public interface IVolador {
    void volar();
}

La lección anterior cerró con el límite de la herencia. Gengar es de tipo fantasma y veneno, y Java no permite que una clase extienda dos superclases.

class Gengar extends Pokemon implements IFantasma, IVeneno { }

fantasma + veneno

dragón + volador

public abstract class Pokemon {
    protected String nombre;
    protected int nivel;
    protected int hp;

    public Pokemon(String nombre, int nivel, int hp) {
        this.nombre = nombre;
        this.nivel = nivel;
        this.hp = hp;
    }

    public abstract void atacar();

    public void mostrarFicha() {
        System.out.println(this.nombre + " | Nv. " + this.nivel
            + " | HP " + this.hp);
    }
}

• Un Pokémon que no vuela, como Pikachu, no debe poder usar ese movimiento, y el error debe detectarse al compilar.
• El recorrido de los voladores no debe consultar la especie de cada Pokémon.

public interface IVolador {
    void volar();
}

public interface IDragon {
    void usarDragoaliento();
}

classDiagram
    class Pokemon {
        <<abstract>>
        #String nombre
        #int nivel
        #int hp
        +atacar() void
        +mostrarFicha() void
    }
    class PokemonElectrico {
        +atacar() void
    }
    class PokemonAgua {
        +atacar() void
    }
    class Gyarados {
        +volar() void
    }
    class Dragonite {
        +atacar() void
        +usarDragoaliento() void
        +volar() void
    }
    class IVolador {
        <<interface>>
        +volar() void
    }
    class IDragon {
        <<interface>>
        +usarDragoaliento() void
    }
    Pokemon <|-- PokemonElectrico
    Pokemon <|-- PokemonAgua
    Pokemon <|-- Dragonite
    PokemonAgua <|-- Gyarados
    IVolador <|.. Gyarados
    IVolador <|.. Dragonite
    IDragon <|.. Dragonite

• PokemonAgua no cambió ni una línea.
• Squirtle y los demás Pokémon de agua siguen sin poder volar.

ArrayList<IVolador> voladores =
    new ArrayList<>();

voladores.add(new Dragonite(
    "Dragonite", 55, 91));
voladores.add(new Gyarados(
    "Gyarados", 40, 95, 120));

for (IVolador v : voladores) {
    v.volar();
}

// no compila, Pikachu no vuela
voladores.add(new PokemonElectrico(
    "Pikachu", 12, 35, 90));

Dragonite vuela sobre el océano.
Gyarados se eleva sobre las olas.

Se solicita imprimir los Pokémon capturados ordenados de menor a mayor nivel.

Collections.sort(capturados);   // no compila

public interface Comparable<T> {
    int compareTo(T otro);
}

public abstract class Pokemon implements Comparable<Pokemon> {
    protected String nombre;
    protected int nivel;
    protected int hp;

    // constructor, atacar y mostrarFicha sin cambios

    public int getNivel() {
        return this.nivel;
    }

    @Override
    public int compareTo(Pokemon otro) {
        return Integer.compare(this.nivel, otro.getNivel());
    }
}

classDiagram
    class Comparable~Pokemon~ {
        <<interface>>
        +compareTo(Pokemon otro) int
    }
    class Pokemon {
        <<abstract>>
        #String nombre
        #int nivel
        #int hp
        +getNivel() int
        +compareTo(Pokemon otro) int
    }
    class PokemonElectrico
    class PokemonAgua
    class Dragonite
    Comparable <|.. Pokemon
    Pokemon <|-- PokemonElectrico
    Pokemon <|-- PokemonAgua
    Pokemon <|-- Dragonite

ArrayList<Pokemon> capturados = new ArrayList<>();

capturados.add(new PokemonElectrico("Jolteon", 30, 65, 400));
capturados.add(new PokemonElectrico("Pikachu", 12, 35, 90));
capturados.add(new Dragonite("Dragonite", 55, 91));
capturados.add(new PokemonAgua("Squirtle", 10, 44, 60));

Collections.sort(capturados);

for (Pokemon p : capturados) {
    p.mostrarFicha();
}

Squirtle | Nv. 10 | HP 44
Pikachu | Nv. 12 | HP 35
Jolteon | Nv. 30 | HP 65
Dragonite | Nv. 55 | HP 91

• String, Integer y Double ya implementan Comparable.
• Por eso una lista de nombres se ordena alfabéticamente con la misma llamada.

public String getNombre() {
    return this.nombre;
}

@Override
public int compareTo(Pokemon otro) {
    int porNivel = Integer.compare(this.nivel,
                                   otro.getNivel());
    if (porNivel != 0) {
        return porNivel;
    }
    return this.nombre.compareTo(otro.getNombre());
}

@Override
public int compareTo(Pokemon otro) {
    return this.nivel - otro.getNivel();
}

• El arreglo es private, así que el cliente no puede recorrerlo de forma directa.
• La primera alternativa es un método que devuelva el arreglo.

// dentro de Equipo
public Pokemon[] getMiembros() {
    return this.miembros;
}

// en el código cliente, con dos integrantes
Pokemon[] miembros = equipo.getMiembros();
for (int i = 0; i < miembros.length; i++) {
    miembros[i].atacar();   // falla en i = 2
}
miembros[0] = null;         // altera el equipo

for (Pokemon p : equipo) {   // no compila
    p.atacar();
}

public interface Iterable<T> {
    Iterator<T> iterator();
}

public interface Iterator<T> {
    boolean hasNext();
    T next();
}

import java.util.Iterator;

public class Equipo implements Iterable<Pokemon> {
    private Pokemon[] miembros;
    private int cantidad;

    public Equipo() {
        this.miembros = new Pokemon[6];
        this.cantidad = 0;
    }

    public void agregar(Pokemon p) {
        this.miembros[this.cantidad] = p;
        this.cantidad++;
    }

    @Override
    public Iterator<Pokemon> iterator() {
        return new IteradorEquipo(this.miembros, this.cantidad);
    }
}

public class IteradorEquipo implements Iterator<Pokemon> {
    private Pokemon[] miembros;
    private int cantidad;
    private int actual;

    public IteradorEquipo(Pokemon[] miembros, int cantidad) {
        this.miembros = miembros;
        this.cantidad = cantidad;
        this.actual = 0;
    }

    @Override
    public boolean hasNext() {
        return this.actual < this.cantidad;
    }

    @Override
    public Pokemon next() {
        if (!hasNext()) {
            throw new NoSuchElementException();
        }
        Pokemon p = this.miembros[this.actual];
        this.actual++;
        return p;
    }
}

classDiagram
    direction LR
    class Iterable~Pokemon~ {
        <<interface>>
        +iterator() Iterator
    }
    class Iterator~Pokemon~ {
        <<interface>>
        +hasNext() boolean
        +next() Pokemon
    }
    class Equipo {
        -Pokemon[] miembros
        -int cantidad
        +agregar(Pokemon p) void
        +iterator() Iterator
    }
    class IteradorEquipo {
        -Pokemon[] miembros
        -int cantidad
        -int actual
        +hasNext() boolean
        +next() Pokemon
    }
    Iterable <|.. Equipo
    Iterator <|.. IteradorEquipo
    Equipo ..> IteradorEquipo : crea

Equipo equipo = new Equipo();
equipo.agregar(new PokemonElectrico("Pikachu", 12, 35, 90));
equipo.agregar(new Dragonite("Dragonite", 55, 91));

for (Pokemon p : equipo) {
    p.atacar();
}

Iterator<Pokemon> it = equipo.iterator();
while (it.hasNext()) {
    Pokemon p = it.next();
    p.atacar();
}

Pikachu lanza 90 V.
Dragonite usa Hiperrayo.

Se solicita liberar a los Pokémon capturados con nivel menor que 15. La lista contiene a Pikachu, Jolteon, Squirtle y Dragonite, en ese orden.

for (Pokemon p : capturados) {
    if (p.getNivel() < 15) {
        capturados.remove(p);
    }
}

Iterator<Pokemon> it = capturados.iterator();
while (it.hasNext()) {
    Pokemon p = it.next();
    if (p.getNivel() < 15) {
        it.remove();
    }
}