10 Periytyminen

Muutettu viimeksi 16.4.2010 / Sivu luotu 9.4.2010 / [oppikirjan esimerkit] / [Scala]

Sivun sisältöä:

• Abstrakti luokka ja aliluokka
• Parametrittomat aksessorit
• Metodien ja kenttien korvaaminen (override)
• Parametroidut kentät
• Yliluokan konstruktorin kutsu
• override
• Polymorfismi
• final

Olio-ohjelmoinnissa luokkia rakennellaan perimällä muita luokkia (inheritance), asettamalla muiden luokkien ilmentymiä luokan jäseniksi (composition) ja ohjelmoimalla luokkiin omia ominaisuuksia, jotka täydentävät ja muuttavat muualta saatuja ominaisuuksia.

Scalan olio-ohjelmointitekniikat muistuttavat kovasti Javan vastaavia; tärkein lisäys ovat piirteet, "traitit", Javan hyvin rajoitettua vähemmän rajoitettu - mutta kuitenkin rajoitettu - moniperintä. Kaikki eivät valttämättä kutsu esim. Javan interface-tekniikkaa "moniperinnäksi". Minä kutsun...;-)

Piirteet esitellään omassa luvussaan. Tässä luvussa käydään tiiviisti läpi Scalan "javamaiset" periytymisjutut.

Abstrakti luokka ja aliluokka

abstract class Moottori {
  def annaKierrosluku(): Double
  def asetaPolttoaineensyottomaara(maara: Double): Unit
  // ... Täällä voisi vallan mainiosti olla myos ei-abstrakteja metodeita!
  // ... Ja jopa sellaisia, jotka kutsuvat abstrakteja metodeita!
}

class Auto(m: Moottori) {  // Moottori on abstrakti luokka!
  // rakennellaan loputkin autosta ...
  def mitenLujaaMennaan() = {
    // nopeus riippuu tavalla tai toisella kierrosluvusta:
    m.annaKierrosluku()/30
  }
  def kaasuta(bensaa: Double) {
    m.asetaPolttoaineensyottomaara(bensaa)
    // ...
  }
  // ties mitä muita metodeita ...
}

class Cosworth extends Moottori {
  private var kierrosluku = 0.0
  // muut tietorakenteet ...

  def annaKierrosluku() = kierrosluku // getteri

  def asetaPolttoaineensyottomaara(maara: Double) {
    kierrosluku =
     if (maara < 0) 0.0
    else if (maara > 100)
      9300.0
    else
      (maara/100)*9300  // tms...
  }
  // muita aksessoreita ...
}

val brrrmmm = new Cosworth()     // "oikea moottori", joka
val lotus49 = new Auto(brrrmmm)  // kelpaa auton luontiin

lotus49.kaasuta(96)
println(lotus49.mitenLujaaMennaan()) // 297.6

lotus49.kaasuta(-23);
println(lotus49.mitenLujaaMennaan()) // 0.0

lotus49.kaasuta(1100)
println(lotus49.mitenLujaaMennaan()) // 310.0

Terminologinen huomautus: Ohjelmointikielistä puhuttaessa esitteleminen (declare) ja määritteleminen (define) tarkoittavat erityisiä asioita: Nimet eli tunnukset esitellään ja nimien eli tunnuksien merkitys määritellään. Yllä luokka Moottori vain esitteli tunnuksen annaKierrosluku. Luokka Cosworth sitten myöskin esittelyn lisäksi määritteli tuon tunnuksen omalla tavallaan.

Parametrittomat aksessorit

Edellä kirjoitettiin tyhjät sulkeet näkyviin:

  def annaKierrosluku(): Double       // abstraktina
  ...
  m.annaKierrosluku()                 // käytössä
  ...
  def annaKierrosluku() = kierrosluku // toteutuksessa

  def annaKierrosluku: Double       // abstraktina
  ...
  m.annaKierrosluku                 // käytössä
  ...
  def annaKierrosluku = kierrosluku // toteutuksessa

"Tapana on", "tyyliin kuuluu", kirjoittaa tyhjä parametrilista näkyviin silloin, kun metodi muuttaa olion kenttiä, kun metodi siis on "setteri" tai sillä on muita sivuvaikutuksia. Tyhjä parametrilista on tapana kirjoittaa myös silloin, kun kyseessä on "getteri", jonka arvo riippuu muuttuvista kentistä.

Mutta sivuvaikutukseton "getteri" immutaabeleista kentistä on tyylin mukaista ohjelmoida ilman tyhjiä sulkeita.

Tässä tyylittelyssä ei ole todellakaan kyse pelkästä "ohjelmointiestetiikasta"! Kun parametriton metodi kirjoitetaan ilman tyhjiä sulkeita, tarvittaessa metodi voidaan korvata kentällä tyyliin;

  // metodit height ja width
  abstract class Element {
    def contents: Array[String]
    def height: Int = contents.length
    def width: Int = if (height == 0) 0 else contents(0).length
  }

  // kentät height ja width
  abstract class Element {
    def contents: Array[String]
    val height = contents.length
    val width = if (height == 0) 0 else contents(0).length
  }

Yksi tärkeä ero metodi- ja kenttäratkaisussa on se, että kenttä vie tilaa ja metodin kutsu puolestaan laskenta-aikaa. Valinta on luokan toteuttajan. Ja oleellista on, että tämä valinta on kapseloitu tuohon luokkaan! Sovelluksen kannalta toiminnallisuus on sama.

"Eikä tässä vielä kaikki": Vaikka abstrakti luokka määrittelisi parametrittoman metodin, toteutusluokka voi toteuttaa sen kenttänä!

abstract class Moottori {
  def annaKierrosluku: Double
  def asetaPolttoaineensyottomaara(maara: Double): Unit
}

class Auto(m: Moottori) {  // Moottori on abstrakti luokka!
  // rakennellaan loputkin autosta ...
  def mitenLujaaMennaan() = {
    // nopeus riippuu tavalla tai toisella kierrosluvusta:
    m.annaKierrosluku/30
  }
  def kaasuta(bensaa: Double) {
    m.asetaPolttoaineensyottomaara(bensaa)
  }
}

class TasaKone extends Moottori {

  val annaKierrosluku = 1000.0 // vakiogetteri

  def asetaPolttoaineensyottomaara(maara: Double) { }
}

val surrur = new TasaKone()     // "oikea moottori", joka
val trabi = new Auto(surrur)    // kelpaa auton luontiin

trabi.kaasuta(96)
println(trabi.mitenLujaaMennaan()) // 33.333333333333336
trabi.kaasuta(-23);
println(trabi.mitenLujaaMennaan()) // 33.333333333333336
trabi.kaasuta(1100)
println(trabi.mitenLujaaMennaan()) // 33.333333333333336

Metodien ja kenttien korvaaminen (override)

Kuten nähtiin, Scalassa kuitenkin myös kentät voivat korvata metodeja. Tästä seuraa tärkeä ero Javaan: kenttien ja metodien nimet kuuluvat samaan nimiavaruuteen, joten niiltä vaaditaan yksikäsitteisyyttä.

Ja todellakin, kenttä voi korvata perityn metodin! Mutta ei toisin päin...

Javassa samannimisyys sallitaan kentille, metodeille, luokille (tyypeille), pakkauksille ja osoitteille (nimetyille lauseille break- ja contunue-lauseita varten). Scalassa tällaisia "nimiavaruuksia" on vain kaksi: arvot (kentät, metodit, pakkaukset, ainokaiset) ja tyypit (luokkien ja piirteiden (trait) nimet).

Parametroidut kentät

Ja vastaavasti var tekee kentästä julkisen muuttujan.. Myös määreet private, protected ja override ovat käytettävissä. Perityn kentän voi korvata myös konstruktorin parametrilistassa:

  class Cat {
    val dangerous = false
  }

  class Tiger(
    override val dangerous: Boolean,
    private var age: Int
  ) extends Cat

 class Tiger(param1: Boolean, param2: Int) extends Cat {
    override val dangerous = param1
    private var age = param2
  }

Yliluokan konstruktorin kutsu

class Piste(private var x: Int, private var y: Int) { 
  def this() = this(0, 0)
  def siirry(dx: Int, dy: Int) {x += dx; y += dy;}
  override def toString = "("+x+","+y+")"
}

val a = new Piste()
val b = new Piste(7, 14)
println(a)               // (0,0) 
println(b)               // (7,14)
a.siirry(2, 3) 
b.siirry(4, 5)
println(a)               // (2,3)
println(b)               // (11,19)

Laaditaan sitten tälle luokalle aliluokka:

class VariPiste(x: Int, y: Int, private var vari: Int)
                                   extends Piste(x, y) {

  def this() = this(0, 0, 0)
  def this(vari: Int) = this(0, 0, vari)

  //-- lisämetodi:
  def uusiVari(vari: Int) {this.vari = vari}

  override def toString = super.toString + " väri: " + vari
}

val c = new VariPiste()
val d = new VariPiste(7)
val e = new VariPiste(4,5,9)
println(c))               // (0,0) väri: 0
println(d))               // (0,0) väri: 7
println(e))               // (4,5) väri: 9
e.siirry(1, 1) // yliluokan operaation käyttö!
println(e))               // (5,6) väri: 9
e.uusiVari(14) // oman operaation käyttö
println(e))               // (5,6) väri: 14

override

• Perityn ei-abstraktin jäsenen korvaamisessa override on pakollinen.
• Perityn abstraktin jäsenen korvaamisessa override on sallittu, mutta ei pakollinen.
• Yliluokan yksityisen (private) jäsenen kanssa saman nimisen jäsenen esittelyssä override on kielletty.
  (Jotkut sanovat, ettei tuollaisia peritä. Ymmärrän heitäkin, mutta itse olen sitä mieltä, että privaattikentätkin peritään, koska ne ovat oliossa, ja vaikka niihin ei aliluokan koodista voikaan viitata... Metodeista voisin olla toistakin mieltä.)
• Ei-perityn eli oman uuden jäsenen kohdalla override on kielletty.

Esimerkki:

abstract class Yli {
  val a = 1
  private val b = 2

  def c = 3
  def d: Int
}

class Ali extends Yli {
  override val a = 10  // pakollinen
  private val b = 20   // kielletty

  override def c = 30  // pakollinen
  def d = 40           // sallittu muttei pakollinen

  val e = 50           // kielletty
} 

abstract class Yli {
  def a = 1
  val b = 2
  var c = 3
  val d = 4
}

class Ali extends Yli {

   override def a = 10 + super.a  // korvattu metodi, viittaus korvattuun metod$

   override val b = 20     // ok
// val xx = 10 +  super.b  // error: super may be not be used on value b

// override var c = 30     // variable c cannot override a mutable variable
// val yy = 10 +  super.c  // error: super may be not be used on variable c

// override var d = 40 // error overriding value d in class Yli of type Int;
                       // variable d is not stable 
}

val x = new Ali
println(x.a)  // 11
println(x.b)  // 20

Polymorfismi

"Arton polymorfismisääntöjä":

Olkoon TyyppiB luokka, joka on luokan TyyppiA välitön tai välillinen aliluokka. Ja olkoon muuttuja x tuon yliluokan tyyppiä: x: TyyppiA

Tällaisen muuttujan arvoksi voi sijoittaa viitteen mihin tahansa olioon, joka on tyyppiä TyyppiA. Koska "jokainen kissa on eläin" eli aliluokan jokainen ilmentymä on myös yliluokan tyyppiä, on luvallista sijoittaa

  x = new TyyppiB()

• Kääntäjä vaatii, että muuttujan x:n luokassa TyyppiA on oltava metodi met(). Eli yksinkertaisesti kääntäjä sallii muuttujalle sovellettavaksi niitä ja vain niitä metodeita, jotka ovat muuttujan omassa luokassa TyyppiA. Myös TyyppiA:n abstrakteja metodeja saa kutsua, koska muuttujan arvona voi olla vain olioita. Ja olioita eli luokan ilmentymiä voi tunnetusti luoda vain ei-abstrakteista luokista.
• Kääntäjä tuottaa koodin, joka ohjelman suoritusaikana käynnistää olion omaan luokkaan TyyppiB ohjelmoidun korvaavan version metodista met(). Tietenkin edellyttäen, että sellainen on.
• Jos TyyppiB-luokassa ei ole metodia met(), valitaan lähin metodin met() toteutus edettäessä luokkahierarkiassa luokasta TyyppiB kohti luokkaa TyyppiA. Kääntäjä on varmistanut, että metodin toteutus todella on olemassa viimeistään luokassa TyyppiA.
• Vaikka muuttujan x arvona olisi olio, jonka luokka TyyppiB on täydentänyt TyyppiA:sta perittyjä metodeja uusilla metodeilla, kääntäjä sallii vain muuttujan tyypin eli TyyppiA:n tuntemat operaatiot.
• Muuttujan tyyppi määrää ja rajaa sallitut operaatiot. Olion tyyppi määrää, mikä versio toisiaan kuormittavista operaatioista lopulta suoritusaikana valitaan.
• Usein tätä menettelyä kutsutaan "dynaamiseksi sidonnaksi": metodin nimeen liitettävä varsinainen metodi valitaan vasta suoritusaikana, ei käännösaikana.

val a: VariPiste = new VariPiste(7)
val b: Piste = a
val c: Any = a

println(a)  // (0,0) väri: 7
println(b)  // (0,0) väri: 7
println(c)  // (0,0) väri: 7

final