Rajapinnat Javassa, osa 1¶

Rajapinta muistuttaa luokkaa, mutta sitä ei ole tarkoitettu määrittämään kokonaisvaltaista toiminnallisuutta vaan lähinnä kuvailemaan tyypin ominaisuudet. Rajapinta määrittää tyypin, jota voi käyttää muuttujien tyyppinä, mutta rajapinnasta itsestään ei voi suoraan luoda olioita vaan rajapintaa vastaavat oliot ovat aina jonkin kyseisen rajapinnan toteuttavan luokan olioita. Edellä käytetty ilmaisu “toteuttaminen” on rajapintojen vastine perinnälle. Esimerkiksi luokka ArrayList toteuttaa rajapinnan List.

Rajapinta määritellään lähes täysin samaan tapaan kuin luokka, mutta määrityksessä käytetään avainsanan class sijaan avainsanaa interface. Alla on esimerkkinä kahden Javan luokkakirjaston tarjoaman varsin yksinkertaisen rajapinnan AutoCloseable ja Readable määritykset (joiden tulisi olla eri tiedostoissa AutoCloseable.java ja Readable.java ja lisäksi sisältää tarvittavat, tästä pois jätetyt, import-lauseet):

public interface AutoCloseable {
  void close() throws Exception;
}

public interface Readable {
  int read(CharBuffer cb) throws IOException;
}

Edellä rajapinta AutoCloseable määrittää tyypin, jolla on julkinen jäsenfunktio void close(), ja rajapinta Readable tyypin, jolla on julkinen jäsenfunktio int read(CharBuffer cb). Nämä funktiot on kuitenkin ainoastaan esitelty: ne ovat ns. abstrakteja jäsenfunktioita eli jäsenfunktioita, joille ei ole määritetty toteutusta (funktion runkoa) vaan ainoastaan funktion otsake. Kun luokka toteuttaa rajapinnan, on sen annettava konkreettiset toteutukset kaikille toteutettavan rajapinnan määrittämille abstrakteille jäsenfunktioille. Edelliset rajapintamääritykset eivät erikseen määrittäneet jäsenfunktioitaan julkisiksi: rajapintojen jäsenfunktiot ovat automaattisesti julkisia, ellei erikseen toisin määritetä.

Luokka voi toteuttaa yhtäaikaa monta eri rajapintaa. Rajapinnan toteuttaminen ilmaistaan lisäämällä luokan nimen perään avainsana implements, jonka perässä luetellaan pilkuilla eroteltuina kaikki luokan toteuttamat rajapinnat. Jos luokka myös perii jonkin yliluokan, annetaan edellä mainittu extends-osuus vasta perityn luokan nimen perässä.

Alla on (sinänsä täysin keinotekoinen) esimerkkikoodi, jossa määritetään ylempänä esitellyt rajapinnat AutoCloseable ja/tai Readable toteuttavat luokat A, B ja C. Näitä kolmea luokka ei ole tässä määritetty julkisiksi, jotta koodia voisi testata asettamatta luokkia A, B ja C erillisin tiedostoihin.

class A implements AutoCloseable {  // A toteuttaa rajapinnan AutoCloseable.
  // Ilmaistaan annotaatiolla @Override, että tässä toteutetaan rajapinnalta "peritty" funktio.
  @Override
  public void close() throws Exception {   // A:n pitää toteuttaa AutoCloseable:n funktio close.
    System.out.println("Closing A...");
  }
}

class B implements AutoCloseable, Readable { // B toteuttaa AutoCloseable:n ja Readable:n.
  @Override
  public void close() throws Exception {           // Toteutettaa AutoCloseable:n funktio close.
    System.out.println("Closing A...");
  }

  @Override
  public int read(CharBuffer cb) throws IOException {  // Toteutettava Readable:n funktio read.
    System.out.println("B is reading...");
    return 0;
  }
}

class C implements Readable {  // C toteuttaa rajapinnan Readable.
  @Override
  public int read(CharBuffer cb) throws IOException {  // Toteutettava Readable:n funktio read.
    System.out.println("C is reading...");
    return 0;
  }
}

public class InterfaceTest {
  public static void main(String[] args) throws Exception {
    // A ja B toteuttavat rajapinnan AutoCloseable, joten niitä voidaan käsitellä
    // AutoCloseable-olioina. Asetetaan A- ja B-oliot AutoCloseable-taulukkoon.
    AutoCloseable[] acs = {new A(), new B()};
    for(AutoCloseable ac : acs) {
      ac.close();  // Tässä voidaan viitata funktioon close, koska AutoCloseable määrittää sen.
    }

    // B ja C toteuttavat rajapinnan Readable, joten niitä voidaan käsitellä
    // Readable-olioina. Asetetaan B- ja C-oliot Readable-taulukkoon.
    Readable[] rs = {new B(), new C()};
    CharBuffer cb = CharBuffer.allocate(0);  // Tyhjä CharBuffer ihan vain read-kutsua varten.
    for(Readable r : rs) {
      r.read(cb);  // Tässä voidaan viitata funktioon read, koska Readable määrittää sen.
    }
  }
}

Tarkemmin ottaen Javassa rajapinnan määritys voi sisältää seuraavia osia:

• Jäsenmuuttujia, joiden on pakko olla julkisia staattisia vakiojäsenmuuttujia, jotka alustetaan suoraan jäsenmuuttujan määrityksen yhteydessä.

  • Kääntäjä olettaa automaattisesti määreet public static final, mutta ne on laillista antaa erikseenkin.

  • Rajapinnat eivät voi määrittää muunlaisia (esim. yksityisiä tai ei-staattisia) jäsenmuuttujia.

• Julkisia jäsenfunktioita (rajapinnan jäsenfunktio on ilman erillistä määritystä public).

  • Abstrakteja ei-staattisia jäsenfunktioita.

    • Abstrakti = ei anneta toteusta vaan ainoastaan esitellään funktio (sen otsake ilman runkoa).

    • Rajapinnan toteuttavan luokan on annettava funktiolle konkreettinen toteutus.

    • Nämä lienevät rajapintojen tärkein osa. Ne määrittävät, millaisia jäsenfunktioita ja siten millaisia toimintoja rajapinnan toteuttavan luokan tulee tarjota.

  • Ei-staattisia jäsenfunktioita, joille on annettu oletustoteutus.

    • Funktion otsakkeen edessä annetaan määre default ilmaisemaan, että kyseessä on oletustoteutus.

    • Kokonainen funktiomääritys, joka toteutetaan samaan tapaan kuin tavallisen luokan jäsenfunktio. Huomaa kuitenkin, että koska rajapinta ei voi määrittää ei-staattisia jäsenmuuttujia, ei oletustoteutus voi viitata sellaisiin vaan sen on pitkälti nojauduttava muihin rajapinnan määrittämiin jäsenfunktioihin.

    • Rajapinnan toteuttava luokka perii oletustoteutuksen (eikä luokan siten ole pakko toteuttaa sitä itse).

  • Staattisia jäsenfunktioita (joille on annettu toteutus; eivät voi olla abstrakteja).

    • Toteutus pitkälti kuin tavallisen luokan staattinen jäsenfunktio.

• Yksityisiä jäsenfunktioita (annettu eskplisiittisesti määre private).

  • Rooli: rajapinnan sisäisiä apufunktioita (käytännössä tarvinnee todella harvoin).

  • Voivat olla ei-staattisia tai staattisia ja niille on pakko antaa toteutus.

Keskitymme etenkin rajapintojen tärkeimpiin osiin eli abstrakteihin jäsenfunktiohin.

Luokan ja sen toteuttaman rajapinnan suhde muistuttaa luokan ja sen perimän yliluokan suhdetta: rajapinnan toteuttaminen tarkoittaa, että luokalla on kaikki rajapinnan määrittämät ominaisuudet ja kyseisen luokan olioita voidaan siten käsitellä toteutetun rajapinnan tyyppisinä olioina. Kuten alussa todettiin, ei rajapinnasta itsesään voi olla olemassa konkreettisia ilmentymiä. Rajapinnan tyyppisinä olioina käsittely tarkoittaa käytännössä sitä, että viitemuuttujan tyyppi voi vastata rajapintaa ja tällaisen viitemuuttujan kautta voidaan viitata kyseisen rajapinnan määrittämiin jäseniin. Esimerkiksi koska rajapinta AutoCloseable määrittää jäsenfunktion close, on AutoCloseable-tyyppisen viitteen kautta sallittua kutsua jäsenfunktiota close.

Rajapinta voi myös periä toisia rajapintoja. Tämä tapahtuu samaan tapaan kuin luokkien kohdallakin käyttäen avainsanaa extends, mutta erona vain mahdollisuus periä yhtäaikaa monta rajapintaa. Perivä rajapinta perii perimiensä rajapintojen kaikki julkiset jäsenet. Tämä tarkoittaa käytännössä, että useita rajapintoja perivän täyttävän luokan on tarjottava toteutukset kaikkien perittyjen rajapintojen abstrakteille jäsenfunktioille.

Eräs yksinkertainen esimerkki rajapintojen välisestä perinnästä on rajapinnan AutoCloseable perivä rajapinta Closeable.

public interface Closeable extends AutoCloseable {
  void close() throws IOException;
}

Rajapinta Closeable määrittää, ja itse asiassa korvaa perimänsä, jäsenfunktion close. Funktioiden ainoa ero on, että rajapinta Closeable tarkentaa funktion close mahdollisesti aiheuttaman poikkeuksen tyypiksi IOException (eikä Exception). Rajapinnan ei tarvitse antaa toteutuksia myöskään perimilleen jäsenfunktioille, ja tässäkin close säilyi abstraktina jäsenfunktiona, jonka rajapinnan toteuttavan luokan tulee toteuttaa.

public abstract class AbstractArray {
  public abstract Object get(int i);               // Lukee indeksin i alkion.
  public abstract void set(int i, Object item);    // Asettaa indeksin i alkion.
  public abstract int size();                      // Palauttaa taulukon koon.

  public void reverse() {  // Kääntää taulukon alkiot päinvastaiseen järjestykseen.
    for(int start = 0, end = size() - 1; start < end; start++, end--) {
      Object tmp = get(start);
      set(start, get(end));
      set(end, tmp);
    }
  }
}

public class Array extends AbstractArray {  // Peritään AbstractArray.
  private Object[] items;        // Alkiot tallettava Object-taulukko.
  private int size;              // Taulukon koko.

  public Array(int size) {       // Rakennin alustaa taulukon parametrin kokoiseksi.
    if(size < 0) {
      throw new NegativeArraySizeException(String.format("Illegal size: %d", size));
    }
    items = new Object[size];
    this.size = size;
  }

  public Object get(int i) {
    if(i < 0 || i >= size) {
      throw new IndexOutOfBoundsException(String.format("Illegal index: %d", i));
    }
    return items[i];
  }

  public void set(int i, Object val) {
    if(i < 0 || i >= size) {
      throw new IndexOutOfBoundsException(String.format("Illegal index: %d", i));
    }
    items[i] = val;
  }

  public int size() {
    return size;
  }
}

Array arr = new Array(3);
arr.set(0, "One");
arr.set(1, "Two");
arr.set(2, "Three");
System.out.format("%s %s %s%n", arr.get(0), arr.get(1), arr.get(2));
arr.reverse();
System.out.format("%s %s %s%n", arr.get(0), arr.get(1), arr.get(2));

One Two Three
Three Two One

Object o = "I am a string";
o.length();      // Kääntäjän virheilmoitus: cannot find symbol o.length().

Object o = "I am a string";
String s = o; // Kääntäjän virheilmoitus: Object cannot be converted to String.
String s = (String) o;     // Laillinen, koska o oikeasti on String.

Object o = "I am a string";
try {
  Integer i = (Integer) o;     // Laiton yritys muuntaa String -> Integer.
}
catch(ClassCastException e) {
  System.out.println("An illegal cast brought me here...");
}

Object o = 3.14F;
System.out.format("o instanceof Object: %b%n", o instanceof Object);
System.out.format("o instanceof Number: %b%n", o instanceof Number);
System.out.format("o instanceof Float: %b%n", o instanceof Float);
System.out.format("o instanceof Constable: %b%n", o instanceof Constable);
System.out.format("o instanceof Double: %b%n", o instanceof Double);

o instanceof Object: true
o instanceof Number: true
o instanceof Float: true
o instanceof Constable: true
o instanceof Double: false

Float f = 3.14F;
Double d = (Double) f;  // Käännösvirhe: Float cannot be converted to Double.
Double d = (double) f;  // Ok: Float -> float -> double -> Double.