Praktikum 5

Polümorfism, liidesed

Ilus päev lõbustuspargis

Lõbustuspargi direktor teeb teie tarkvaraettevõttega lepingu, et te kirjutaksite lõbustuspargi ameerika mägede atraktsioonile vanusekontrolli programmi. Atraktsioonile lubatakse alates 12 eluaastast ja tavaliselt on noortel kaasas ID-kaart või õpilaspilet, mida peaks kontrollima. Seejuures kontrollida tuleb terve vagunitäis rahvast korraga.

public class IdKaart {
  private String isikukood;
  public IdKaart(String isikukood) {
    this.isikukood = isikukood;
  }
  public boolean onVähemalt12Aastane() {
    int praeguneAasta = LocalDate.now().getYear(); 
    return sünniaasta() <= praeguneAasta - 12;
  }
  private int sünniaasta() { // 4. praktikumi 2. harjutus 
    int algus = Integer.parseInt(isikukood.substring(0, 1));
    int aasta = Integer.parseInt(isikukood.substring(1, 3));
    if (algus <= 2)
      return 1800 + aasta;
    if (algus <= 4)
      return 1900 + aasta;
    if (algus <= 6)
      return 2000 + aasta;
    return 2100 + aasta;
  }
}

public class Õpilaspilet {
  private int sünniaasta;
  public Õpilaspilet(int sünniaasta) {
    this.sünniaasta = sünniaasta;
  }
  public boolean onVähemalt12Aastane() {
    return sünniaasta + 12 <= LocalDate.now().getYear();
  }
}

public class AmeerikaMäed {
  public boolean vanusedSobivad(IdKaart[] idKaardid, Õpilaspilet[] õpilaspiletid) {
    for (IdKaart id : idKaardid) {
      if (!id.onVähemalt12Aastane())
        return false;
    }
    for (Õpilaspilet pilet : õpilaspiletid) {
      if (!pilet.onVähemalt12Aastane())
        return false;
    }
    return true;
  }
}

LocalDate klassist saad täpsemalt lugeda siit:

• https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/time/LocalDate.html
• https://docs.oracle.com/javase/tutorial/datetime/iso/index.html

Nädal aega hiljem helistab lõbustuspargi direktor ja ütleb, et mõned inimesed tahavad enda vanust hoopis juhiloaga tuvastada. Selle jaoks tuleb koodis vajalikud muudatused teha.

Sarnase eesmärgiga objektide tüübid

Näiteülesandes kujutatud dokumente võib olla palju erinevaid ja nende kõigi jaoks koodis muudatusi tehes läheb asi kiirelt käest ära. Peab leiduma parem lahendus!

Koodist on näha, et iga dokumendi klass teeb vanusekontrolli erinevalt - sõltuvalt sellest, mis andmed seal olemas on. Meetodit vanusedSobivad tegelikult ei huvita, kuidas täpselt see vanusekontroll toimib. Tähtis pole lõpuks ka see, millise dokumendiga tegemist on, niikaua kuni selle põhjal on võimalik vanust kontrollida.

Näites on igal dokumendiklassil samasugune boolean onVähemalt12Aastane() meetod. Oleks mõistlik, kui vanusedSobivad meetodile saaks kõik dokumendid ühe massiivina ette anda, sest onVähemalt12Aastane meetodi väljakutse on kõigi isendite puhul samasugune. Pythonis see niimoodi töötabki ja töötaks ka Javas. Paraku Java kompilaator on nõus kompileerima ainult sellist koodi, mille toimimises ta kompileerimise hetkel kindel saab olla ja selle otsustab ta väljakirjutatud muutujatüüpide järgi. Mis tüüpi peaks olema dokumentide ühine massiiv, et kompilaator vajaliku meetodi olemasolus kindel saaks olla? Selle probleemi aitavad lahendada liidesed.

Liidese definitsioon

Liides (interface) on süntaksi mõttes klassile sarnane struktuur, mis kirjeldab komplekti meetodeid. Kirja pannakse meetodite nimed, tagastustüübid ja parameetrite tüübid, aga meetodi kehad jäetakse täpsustamata. Eesmärk on kirjeldada funktsionaalsust, mis mingil objektil peaks olema. Seejuures räägitakse ainult oodatavast käitumisest, aga mitte sellest, mis klassi objektiga tegu on, ega täpsest algoritmist, mida funktsionaalsuse saavutamiseks kasutatakse. Mõned näited:

public interface Hulknurk {
  // Hulknurga pindala arvutatakse eri kujundite puhul erinevalt. Liides ütleb, et 
  // objektil peaks selline meetod olema, aga ei täpsusta, mis valemit kasutatakse.
  double pindala(); 

  // hulknurga nurkade arv sõltub kujundist, aga seda peab saama tuvastada
  int nurkadeArv(); 
}

public interface Väljund {
  // ei täpsusta, kas väljastatakse faili või käsureale või kuhugi mujale
  void väljasta(String väärtus); 
}

Liideseid saab Eclipse-is teha sarnaselt klassidega (New --> Interface). IntelliJ-s tee liides samamoodi nagu klass ja muuda koodis märksõna class interface'ks.

Kui mingis klassis on kõik liideses kirjeldatud meetodid olemas, siis öeldakse, et klass realiseerib liidese (implements an interface). Eestikeelse terminina kasutatakse ka sõna "implementeerima". Selle kursuse raames loeme neid sünonüümideks ja kasutame mõlemaid. Selleks, et asi veel kindlam oleks, antakse oma kavatsusest teada ka kompilaatorile:

public class Kolmnurk implements Hulknurk {
  private double a, b, c; // küljed
  public Kolmnurk(double a, double b, double c) {
    this.a = a;
    this.b = b;
    this.c = c;
  }
  public double pindala() {
    // Heroni valem
    double s = (a + b + c) / 2.0;
    return Math.sqrt(s * (s - a) * (s - b) * (s - c));
  }
  public int nurkadeArv() {
    return 3; 
  }
  public boolean onTäisnurkne() {
    // Klassis peavad olema realiseeritud kõik liidese meetodid, aga see ei tähenda,
    // et kõik klassi meetodid peavad olema liideses kirjeldatud. Liidesega klass 
    // on ikka tavaline klass, kuhu võib oma soovi järgi igasuguseid meetodeid lisada.
    double[] abc = {a, b, c};
    java.util.Arrays.sort(abc);
    double kaatet1 = abc[0] * abc[0];
    double kaatet2 = abc[1] * abc[1];
    double hüpotenuus = abc[2] * abc[2];
    return Math.abs(kaatet1 + kaatet2 - hüpotenuus) < 0.001; // ümardusviga
  }
}

Lisades klassi kirjeldusse implements ja siis mingi liidese nime, tehakse kokkulepe klassi looja ja kompilaatori vahel. Klassi looja lubab, et loodud klassis on kõik liideses kirjeldatud meetodid olemas. Kui see niimoodi ei ole, siis kompilaator keeldub klassi kompileerimast. Vastutasuks lubab kompilaator kasutada loodud klassi isendeid seal, kus on muutuja tüübiks oodatud hoopis liidese tüüp:

Kolmnurk kolmnurk = new Kolmnurk(3, 4, 5); 
Hulknurk hulknurk = kolmnurk; // toimib, sest Kolmnurk realiseerib Hulknurka!
System.out.println(kolmnurk.nurkadeArv()); // 3
System.out.println(hulknurk.nurkadeArv()); // 3

static void näidisMeetod(Hulknurk h) { ... }

näidisMeetod(kolmnurk);
näidisMeetod(new Kolmnurk(3, 4, 5));

Kui klass realiseerib liidest, siis sisuliselt on selle klassi isend korraga mitut tüüpi - klassi enda tüüpi ja realiseeritud liideste tüüpi. Sellist nähtust nimetatakse polümorfismiks (polymorphism). (Liideste kasutamine pole ainus polümorfismi vorm.)

Mõned reeglid liideste kohta:

• Liides on tüüp. Seda saab kasutada lokaalse muutuja tüübina, isendivälja tüübina, meetodi parameetri tüübina jne - täpselt nagu klassi.
• Liidesest ei saa isendeid luua (new Hulknurk() ei kompileeru), sest seal on meetodite kehad puudu. Isendeid saab luua klassidest, mis liidest realiseerivad.
• Mitu erinevat klassi saavad realiseerida sama liidest (nt Kolmnurk ja Nelinurk).
• Üks klass saab realiseerida mitu liidest. Liideste nimed eraldatakse komaga: class TekstiFail implements Sisend, Väljund { .. }
• Kui liidese meetodil ei ole piiritlejat (public/private), siis loetakse see public meetodiks. Isegi, kui liideses ei ole public võtmesõna välja kirjutatud, peab meetodit realiseerivas klassis public välja kirjutama.

Objektide identiteet

Kasutades new võtmesõna saame me luua uusi objekte (isendeid). Objekti loomisel tuleb new järgi kirja panna konkreetne klassi nimi, millest isendit luuakse. Loodud objekt jätab alati meelde, mis klassi isend ta on - seda informatsiooni ei saa objektist lahutada. Iga objekti küljes on meetod getClass, mille abil saab seda informatsiooni ka küsida (kasulik vigade otsimisel). Kui klass realiseerib liideseid, siis ta oskab käituda ka nende liideste isenditena, sh saab teda nende liideste tüüpi muutujatesse salvestada. See ei muuda objekti klassi!

Kolmnurk kolmnurk = new Kolmnurk(3, 4, 5);
System.out.println(kolmnurk.getClass()); // class Kolmnurk
Hulknurk hulknurk = new Kolmnurk(3, 4, 5);
System.out.println(hulknurk.getClass()); // class Kolmnurk

hulknurk.onTäisnurkne(); // compile error: cannot resolve method
Kolmnurk samaKolmnurk = hulknurk; // compile error: incompatible types

Iga jooksvas programmis elav objekt teab, millise klassi isend ta on ja mis meetodid tema küljes on. See-eest kompileerimise hetkel näeb kompilaator ainult staatilisi tüüpe - tüüpe, mis on programmeerija poolt välja kirjutatud või koodist üheselt mõistetavalt tuletatavad. See seab mõnikord tobedaid piiranguid - kuna kompilaator näeb ainult väljakirjutatud tüüpe, lubab ta kasutada ainult meetodeid, mis väljakirjutatud tüüpide küljes on, isegi kui muutuja viidatud objekti küljes on ka teisi meetodeid.

Näiteks ülal toodud koodinäites samaKolmnurk muutuja väärtustamise juures näeb kompilaator ainult seda, et muutuja hulknurk on Hulknurk tüüpi. Kuigi Kolmnurk realiseerib Hulknurga liidest, võivad seda liidest realiseerida ka teised klassid. Kompilaator ei saa olla kindel, et iga Hulknurk on Kolmnurk ja seetõttu ta ei luba samaKolmnurk väärtustada. Samal põhjusel ei saa Hulknurk tüüpi muutuja küljes kutsuda Kolmnurga meetodeid, mis pole ka Hulknurgas kirjeldatud.

Näiteid Java sisseehitatud liidestest

java.lang.Comparable

https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Comparable.html

Liides Comparable kirjeldab compareTo meetodi kahe objekti võrdlemiseks. Liidest kasutatakse näiteks Java sorteerimisalgoritmide poolt. Erinevate realisatsioonidega saab määrata, mis omaduse järgi ja mis järjekorras objektid peaksid sorteeritud saama (oluline, kui te enda loodud klassi isendeid tahate sorteerida). Näiteks kolmnurkade omavahel pindala järgi võrreldavaks muutmiseks tuleks muuta Kolmnurk klassi:

public class Kolmnurk implements Hulknurk, Comparable<Kolmnurk> {
  public int compareTo(Kolmnurk võrreldav) {
    if (pindala() < võrreldav.pindala())
      return -1; // negatiivne arv näitab, et this on väiksem kui võrreldav
    if (pindala() > võrreldav.pindala())
      return 1; // positiivne arv näitab, et this on suurem kui võrreldav
    return 0; // null tähendab, et mõlemad on võrdsed
  }
  // ülejäänud kood sama
}

java.util.List

https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html

Liides List kirjeldab meile juba tuttavat funktsionaalsust, mille meetodid on näiteks add, get ja size. List on liides, sest seda saab realiseerida erinevat moodi, sõltuvalt sellest, millised operatsioonid peavad kiirelt jooksma. Näiteks ArrayList realisatsioon võimaldab elemente kiirelt indeksi järgi leida, aga LinkedList realisatsioon võimaldab suvalistel indeksitel kiirelt elemente lisada või eemaldada.

Sarnane liides on ka java.util.Map.

java.lang.Iterable

https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Iterable.html

Liides Iterable kirjeldab meetodi iterator. Iteraatorid on abiks objektide sisu läbi vaatamisel. Näiteks ArrayList realiseerib Iterable liidese. Java for (T element : elemendid) süntaks ei kontrolli tegelikult, kas elemendid tüüp on list/massiiv, vaid kas tüüp on Iterable. Seega on igaühel võimalik luua klass, mille sisu saab sellise for tsükliga läbi vaadata.

Tagasi lõbustusparki

Vaatame nüüd uuesti meie AmeerikaMäed klassi ja tema sadat häda. Vaadates vanusedSobivad meetodit on selge, et see oleks nõus kasutama kõiki objekte, millel on meetod onVähemalt12Aastane. Loome talle vastava liidese ja kasutame seda:

public interface Dokument {
  boolean onVähemalt12Aastane();
}

public class AmeerikaMäed {
  public boolean vanusedSobivad(Dokument[] dokumendid) {
    for (Dokument dokument : dokumendid) {
      if (!dokument.onVähemalt12Aastane())
        return false;
    }
    return true;
  }
}

Lisaks sellele peavad IdKaart ja Õpilaspilet realiseerima meie uut liidest. Vaatame, kuidas see kõik kokku läheks.

public class IdKaart implements Dokument {
  // ülejäänud kood ei muutu
}

public class Õpilaspilet implements Dokument {
  // ülejäänud kood ei muutu
}

public class Test {
  public static void main(String[] args) {
    AmeerikaMäed mäed = new AmeerikaMäed();
    Dokument[] dokumendid = {
        new IdKaart("39108071234"),
        new Õpilaspilet(1991)
    };
    System.out.println("sobib: " + mäed.vanusedSobivad(dokumendid));
  }
}

Link tervele lõpplahenduse koodile: https://github.com/mbakhoff/oop-samples/tree/master/interfaces/sample1/src

public class FailiLogija {
  private PrintWriter logiFail;

  public FailiLogija(PrintWriter logiFail) {
    this.logiFail = logiFail;
  }

  public void logiFaili(String teade) {
    logiFail.println(teade);
    logiFail.flush(); // kirjuta kohe faili
  }
}

public class KäsureaLogija {
  public void logiKäsureale(String teade) {
    System.out.println(teade); 
  }
}

public class Vagun {
  private int kütus;
  public Vagun(int kütus) {
    this.kütus = kütus;
  }
  public int kütuseTase() {
    return kütus;
  }
}

public class KütuseMõõtja {
  private Logija logija;
  public KütuseMõõtja(Logija logija) {
    this.logija = logija;
  }
  public void mõõdaKütust(Vagun vagun) {
    // logi siin vaguni kütusetase
    // kui kütusetase on alla 10 ühiku, siis logi ka hoiatus
  }
}

public class Test {
  public static void main(String[] args) throws Exception {
    Logija logija;
    // args on käsurea argumendid
    if (args.length == 1 && args[0].equals("kirjuta-faili")) {
      logija = new FailiLogija(new PrintWriter("logi.txt", "UTF-8"));
    } else {
      logija = new KäsureaLogija();
    }

    KütuseMõõtja mõõtja = new KütuseMõõtja(logija);
    List<Vagun> vagunid = Arrays.asList(
          new Vagun(33),
          new Vagun(5));
    for (Vagun vagun : vagunid) {
        mõõtja.mõõdaKütust(vagun);
    }
  }
}