10. előadás

Interface (interfész, interf-a-c-e)

Egy objektum hozzáférhetőségét megvalósító legtisztább ősosztály

public interface Rational {
    public int getNumerator();
    public int getDenominator();
    public Rational times( Rational that );
    public Rational times( int that );
    public Rational plus( Rational that );
}

Csak a metódusok szignatúráját tartalmazza, az implementációt nem - abstract, implementáció nélküli műveletek

A metódusok szignatúrájukon túl mást nem tartalmaz, ezzel kötelezve a leszármazott osztályt a metódusok felüldefiniálására és biztosítja annak kiterjesztett viselkedését (ami jellem).

Az abstract és public kulcsszókat el lehet hagyni, hiszen egyértelműek.

public az interface kulcsszó előtt: Más csomagból is használható az interface. Pl.:

public interface Rational {}

Interface definíciója

Példánymetódusok deklarációja: specifikáció és ;:

int getNumerator();

• Konstansok definíciója: public static final
• Statikus metódus
• Beágyazott (tag-) típus

Interface megvalósítása

public class Fraction implements Rational {
    private final int numerator, denominator;
    public Fraction( int numerator, int denominator ){ /*...*/ }
    // A következő metódusokat SZÜKSÉGES implementálni, az interface szerint
    public int getNumerator(){ return numerator; }
    public int getDenominator(){ return denominator; }
    public Rational times( Rational that ){ /*...*/ }
}

Sorozat típusok (ismét)

• int[]
• java.util.ArrayList<Integer>
• java.util.LinkedList<Integer>

ArrayList<T> és a LinkedList<T> is implementája a List<T> interface-t.

\(\forall\) T: ArrayList<T> altípusa List<T>-nek \(\forall\) T: LinkedList<T> altípusa List<T>-nek

Liskov's substitution principle (LSP) használható!

Game of Codes

Az interface egy típus

List<String> names;
static List<String> noDups( List<String> names ){
    // Itt lehet használni a List által definiált metódusokat
}

Az interface nem példányosítható!

List<String> names = new List<String>(); // fordítási hiba

Egy interface-t implementáló típus downcast-olható az interface-szé:

List<String> names = new ArrayList<>();

Speciális jelentésű interface-ek

• java.lang.Iterable<T> - működik rajta az iteráló ciklus
• java.lang.AutoClosable - műküdik rá a try-with-resources
• java.lang.Cloneable - sekély másolás
• java.io.Serializable - működik rá az objektumszerializáció

Iterable, Iterator interface

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

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

long sum( Iterable<Integer> is ){
    long sum = 0L;
    Iterator<Integer> it = is.iterator();
    while( it.hasNext() ){
        sum += it.next();
    }
    return sum;
}

// `sum` meghívható bármivel, ami implementája az `Iterable`-t

Lambdák használata interface-szel

interface IntIntToInt{
    int apply(int left, int right);
}

static int idunno(IntIntToInt fun){
    return fun.apply(1, 2);
}

zipWith((n, m) -> n*m); //Dark magic!