3.4 Lauseita

Kuten edellisen luvun alussa todettiin, lauseke (expression) on ohjelmointikielen ilmaus, jolla on jokin arvo ja tuolla arvolla on jokin tyyppi. Lause (statement) puolestaan ilmaisee jonkin algoritmisen toiminnon, "tehdään jotakin"... Javassa on lisäksi lausekelauseita (expression statements), joita voi käyttää sekä lausekkeen, että lauseen tapaan. Laskettua arvoa ei jälkimmäisessä tapauksessa käytetä mihinkään. Laskennalla voi kuitenkin olla haluttuja (sivu-)vaikutuksia.

Ns. rakenteisten lauseiden tehtävä on valita suoritettavia lauseita, toistaa lauseita, ... Ne ovat rakenteisia, juuri siksi, että niiden rakenneosina on lauseita.

Yksinkertaiset lauseet päättyvät aina puolipisteeseen. Rakenteisilta lauseilta tätä ei vaadita. Sallittua se silti on, koska Javassa on ns. tyhjä lause.

Tämä luku esittelee tiiviisti useimmat Javan lauseet.

• Lohkot ja muuttujien määrittelylauseet
• Lausekelauseet
• Ehdolliset lauseet if ja if-else
• Valintalause switch
  • Komentotulkki
• Ehdolliset toistolauseet while ja do
• For--toisto
• For-each-toisto
• Keskeytyslauseet break, continue ja return
• Muita lauseita

Lohkot ja muuttujien määrittelylauseet

{ int a = 1, b, c = 2*a;
  b = a * 2;
  int d = a + b;   // d on käytössä vasta tästä alkaen!!
  { int e = d + b; // e on käytössä tästä alkaen
    d = a + e;
  }                // e:n käyttöalue loppuu tähän
  c = d + b;
}

Huomattavaa:

• Lohkoa voi käyttää kaikkialla, missä lause on sallittu. Usein lohkoa käytetään rakenteisen lauseen alilauseena, koottuna lauseena.

• Jokaisen metodin runko (body) eli metodin algoritmi on lohko (tai tyhjä: ";").

• Muuttujien nimien on metodissa oltava yksikäsitteisiä! Jo määriteltyä muuttujan nimeä ei voi sisemmässä lohkossa uudelleenmääritellä. (Mutta ilmentymä- ja luokkamuuttujien peittäminen metodin paikallisella muuttujalla tai aliluokan ilmentymä- tai luokkamuuttujalla on mahdollista. Tähän palataan myöhemmin.) Seuraava tapaus on kuitenkin mahdollinen:

       { //...
         { int i;
           //...
         }
         { int i;
           //...
         }
         int i;
         //...
       }
  

  Metodin muuttujalla ei missään ohjelmakohdassa saa olla kahta merkitystä.

• for-lauseen alussa määritelty muuttuja ("for (int i=1; ...") on tapa määritellä askelmuuttuja paikallisena for-lauseen toistamaan lauseeseen (usein lohkoon).

• (Java sallii eri tehtäviin käytettyjen tunnusten samannimisyyden, esim. muuttujalla, luokalla, metodilla, luokan kentällä ..., voi olla sama nimi, mutta ei tällaisessa nimien säästämisessä mitään järkeä ole!)

• Jos metodin muuttuja määritellään final-määreellä, muuttuja on ns. nimetty vakio. Nimetylle vakiolle saa kerran sijoittaa arvon. Yleensä se tehdään alkuarvonasetuslausekkeessa. Ensimmäisen arvon asettamisen jälkeen tällaisen "muuttujan" arvoa ei enää voi muuttaa. (Myös muodollinen parametri voidaan määritellä vakioksi. Silloin metodi ei voi lainkaan muuttaa tuon parametrin arvoa. Vakiot on tapana kirjoittaa kokonaan isoin kirjaimin.

Esimerkkejä muuttujien määrittelyistä (Esimerkit havainnollistavat määrittelyiden monia mahdollisuuksia, älkööt ne kuitenkaan ketään innostako vaikeaselkoisuuteen!):

long i;
int j = 1, k = 2, m, n = 0;

int eka=1, toka=eka+1, kolm=eka+2, nel=kolm+1;

double dd = 6.0, ee = dd*3.14;
float  ff = 3.21F;  // Liukulukuvakiot ovat
         // ----^!     oletusarvoisesti double-tyyppisiä!

int    ii = (int)ee, jj = '2';
char   cc = '#', bb = (char)dd;

String gg ="Miau!", hh = "tulos on "+ (ff+dd);
String nnn = 2 + 3 + "böö";   //nnn:n arvoksi tulee "5böö"
String mmm = 2 + (3 + "böö"); //mmm:n arvoksi tulee "23böö"

Pikkuvarasto rr, pp = null, qq = new Pikkuvarasto(10.0, "Mehu"); 

Kääntäjä tarkistaa, ettei metodissa käytetä arvon antajana - esimerkiksi sijoitusoperaation oikena puolena tai tulostettavana - sellaista muuttujaa, jolle ei ole asetettu alkuarvoa. Kääntäjä tekee ns. tietovirta-analyysin (data flow analysis) hyvin epäluuloisena: Jos tuollaista muuttujaa jossain tilanteessa edes saatettaisiin käyttää, kääntäjä ei anna armoa!

Huom: Koska määrittely on suoritettava lause, alkuarvon antava lauseke lasketaan kaikkine sivuvaikutuksineen joka suorituskerralla:

int a = 1;
for (int i=1; i<=3; ++i) {
  Pikkuvarasto c = new Pikkuvarasto(i*10.0, "Mehu");
  int b = ++a;

  System.out.println(b);
  // ...
}

Lausekelauseet

Vain seuraavia lausekkeita voi käyttää lauseina:

• sijoitus (=, +=, -=, *=, /=, %=, ...)
• kasvatus ja vähennys (++i, i++, --i, i--)
• arvon palauttavan metodin kutsu
• olion luonti (new)

Huom: Muita lausekkeita ei siis voi käyttää lauseina!

Esimerkkejä:

  i = 1;
  j = i + 4;

  ++i; // Kun 1:llä kasvatus- tai vähennyslauseketta 
  j++; // käytetään lauseena, järjestyksellä ei ole väliä!

  mehua.otaVarastosta(15); //vaikka:
                           // public double otaVarastosta(double)
                           //        ^^^^^^

  new Pikkuvarasto(); // konstruktorin suoritus voi joskus
                      // olla ainoa, mitä halutaan

Ehdolliset lauseet if ja if-else

  if (ehto)
    lause


  if (ehto)
    lause1
  else
    lause2

• Ehdon on oltava totuusarvoinen lauseke eli looginen lauseke.
• else-osa liittyy lähimpään edeltävään if-lauseeseen, johon ei ole vielä liittynyt else-osaa. Sulkemalla else-osaton if-lause lohkoksi, else-osa voidaan liittää kauemmas:

  if (a<b)
    {if (c<d)
       e = f;
    }
  else
     g=h;
  

  Ilman tuota lohkoa else-osa liittyisi sisempään if-lauseeseen. (Sisentelystä riippumatta.)

Valintalause switch

  switch (lauseke) {
    case vakio1: lause1;
                 break;
    case vakio2: case vakio3:
                 lause2;
                 lause3;
                 break;
    default:     lause4;
                 break;
  }

• Lausekkeen tyyppi voi olla vain char, byte, short tai int.
• Jokaisen valintavakion täytyy olla sijoitettavissa lausekkeen tyyppiseen muuttujaan.
• Yksi valintavakio voi esiintyä vain kerran.
• default voi esiintyä korkeintaan kerran.
• Jos ohjelmoidaan "yksi vaihtoehto monista" -rakenne (kuten yllä), vaihtoehdot lopetetaan break-lauseeseella.

• Jos johonkin valintaan liittyvän lausejonon viimeisenä ei ole break-lausetta, suoritus jatkuu seuraavan valintavaihtoehdon lausejonoon:

  //lähtölaskenta (korkeintaan 3:sta)
  int lkm;
  // ...
  switch (lkm) {
    case 3: System.out.print("kolme, ");
    case 2: System.out.print("kaksi, ");
    case 1: System.out.print("yksi, ");
    case 0: System.out.print("nolla: ");
  }
  System.out.println("PUM!"); 
  

  Jos muuttujan lkm arvo on 3, ohjelmanpätkä tulostaa:

  kolme, kaksi, yksi, nolla: PUM!
  

• Jos mikään valintavakio ei tärppää eikä default-osaa ole, switch-lause toimii kuin tyhjä lause eli ei tee mitään.
• Literaalivakioiden lisäksi valintavakioina voi käyttää nimettyjä vakioita. (Nämä ovat jossain luokassa - ei metodissa - määriteltyjä kenttiä "public final static", nämä käsitellään myöhemmin)
• Koska char-tyyppi kuuluu kokonaislukutyyppeihin merkkejä (esim. 'a') voi käyttää valintavakioina. (String-olioita, esim. "a", ei voisi tässä käyttää!)

  Esimerkki: Klassinen tapa toteuttaa tietokoneen käyttöliittymä on ns. komentotulkki (Komentotulkki.java):

  import java.util.Scanner;
  
  public class Komentotulkki {
  
    private static Scanner lukija = new Scanner(System.in);
  
    private static void teeA() {
      System.out.println("Toteutan operaation a");
      // ... tehdään työt ...
    }
    private static void teeB() {
      System.out.println("Toteutan operaation b");
      // ... tehdään työt ...
    }
    private static void teeC() {
      System.out.println("Toteutan operaation c");
      // ... tehdään työt ...
    }
    private static void teeD() {
      System.out.println("Toteutan operaation d");
      // ... tehdään työt ...
    }
  
    public static void main(String[] args) {
      char komento;
      do {
         // kirjoitetaan kehoitemerkki
         System.out.print("kone> ");
  
         // eristetään komento             //  Huom: Jos komentoon
         String rivi = lukija.nextLine();  //  liittyisi parametreja,
         if ( rivi.length() > 0 )          //  nekin löytyisivät
           komento = rivi.charAt(0);       //  muuttujasta rivi!
         else
           komento = 'ö';  // mikä vain virheellinen merkki!
  
         // valitaan operaatio
         switch (komento) {
           case 'a': teeA();
                     break;
  
           case 'b': teeB();
                     break;
  
           case 'c': teeC();
                     break;
  
           case 'd': teeD();
                     break;
  
           case 'l': break; // LOPETUSKOMENTO ON 'l'
  
           default:  System.out.println("Virheellinen komento!");
                     break;
         }
       } while (komento!='l');
  
    }
  }
  
  

• Huom: Äskeinen komentotulkki voidaan toteuttaa myös vallan mainiosti if-lausein (KomentotulkkiB.java):

    ...
    public static void main(String[] args) {
      char komento;
  
      while (true) {  // "ikuinen" toisto keskeytetään break-lauseella
         ...
  
         // valitaan operaatio
         if (komento=='a')
           teeA();
         else if (komento=='b')
           teeB();
         else if (komento=='c')
           teeC();
         else if (komento=='d')
           teeD();
         else if (komento=='l')
           break; // ************** katkaistaan "ikuinen" toisto **************
         else 
           System.out.println("Virheellinen komento!");
  
       } // end of while (true)
    }
  
  

• Myös lueteltua tyyppiä voidaan käyttää valintavakiona:

    public enum Maa  { RISTI, HERTTA, PATA, RUUTU }
    ...
  
    Maa maa = Maa.HERTTA;
  
    switch (maa) {
      case RISTI: case PATA:
         System.out.println(maa + " on musta.");
         break;
      case HERTTA: case RUUTU:
         System.out.println(maa + " on punainen.");
         break;
      }
  
  
  

Ehdolliset toistolauseet while ja do

  while (ehto) 
    lause


  do
    lause
  while (ehto);

• Ehdon on oltava totuusarvoinen lauseke.
• While-lause ei välttämättä suorita alilausettaan kertaakaan, do-lause suorittaa alilauseensa ainakin kerran:
  • while-lauseen mahdolliset laskentajonot, "suoritushistoriat", ovat

    ehto
    ehto-lause-ehto
    ehto-lause-ehto-lause-ehto
    ...

  • do-lauseen mahdolliset laskentajonot, "suoritushistoriat", ovat

    lause-ehto
    lause-ehto-lause-ehto
    lause-ehto-lause-ehto-lause-ehto
    ...

For-toisto

  for (alustuslauseke; ehto; kasvatuslauseke)
    lause

For-lauseen mahdolliset laskentajonot, "suoritushistoriat", ovat:

alustus-ehto
alustus-ehto-lause-kasvatus-ehto
alustus-ehto-lause-kasvatus-ehto-lause-kasvatus-ehto
...

For-lause vastaa rakennetta:

  {
    alustuslauseke;
    while (ehto) {
      lause
      kasvatuslauseke;
    }
  }

For-lause voidaan nähdä "toiston yleisenä neliparametrisena rakenteena, johon kuuluu alkutoimet, päättöehto, päivitystoimet (kunkin toiston jälkeen) ja toistettava" (Tomi Silander).

• Alustus- ja kasvatuslauseke voivat olla lausekelauseeksi kelpaavia lausekkeita (tai tyhjiä tai muuttujan määrittelylauseita tai ...)
• Ehdon on oltava totuusarvoinen lauseke. Ehto voi olla myös tyhjä: se ymmärretään tällöin vakioksi true.
• Alustus- ja kasvatuslausekkeena voi käyttää myös pilkulla erotettujen lausekkeiden listoja:

  for (int i=1, j=20;  i<j;  i+=2, j-=3)
          System.out.println(i + " " + j);
  

  Ohjelmanpätkä tulostaa:

  1 20
  3 17
  5 14
  7 11
  

• For-lauseella voi halutessaan ohjelmoida hyvin vaikeaselkoisesti. Sellainen ei kuitenkaan ole sallittua tällä kurssilla!
• Tavallisesti for-lauseella "käydään läpi arvoalueita". Muunlaiset toistot on usein selkeämpää ohjelmoida ehdollisilla toistolauseilla. Taas kerran: Kaikki mahdollinen ei ole toivottavaa!

For-each-toisto

Javan versio 1.5 toi mukanaan uuden tavan käydä läpi taulukon kaikki alkiot ilman tarvetta itse indeksoida. For-lauseen uusi syntaksivaihtoehto on

    for (alkio : taulukko)
      käsittele alkio;

Tällaisella semantiikalla varustettua for-toistoa kutsutaan joissakin ohjelmointikielissä for-each-toistoksi ilmeisestä syystä. Javassa tällainen on käytettävissä talukon kaikkien alkioiden läpikäynnin lisäksi myös ns. kokoelmatyypeille (Collections). Uusi for-lause käy niissäkin yksitellen läpi kaikki tietorakenteen alkiot.

Esimerkki: Ohjelmoidaan metodi, joka laskee int-taulukon alkioiden summan ja palauttaa sen arvonaan. Summaa laskettaessa ei ole kiinnostavaa, missä järjestyksessä lasketaan eikä ole kiinnostavaa, mikä kunkin alkion indeksi on. Tämä on siis varsin oivallinen tilanne kayttää for-each-toistoa! (LaskeSumma.java)

  private static int alkiodenSumma(int[] taulukko) {
    int summa = 0;
    for (int alkio : taulukko)
       summa = summa + alkio;
    return summa;
  }

Huom: Itse asiassa for-each-lauseella voidaan taulukon alkioiden lisäksi käydä läpi ns. kokoelmien (Collections) alkioita. Myös luetellun tyypin arvoalue voidaan käydä läpi:

  public enum Arvo { KAKKONEN, KOLMONEN, NELONEN, VITONEN,
                     KUTONEN, SEISKA, KASI, YSI, KYMPPI,
                     JÄTKÄ, ROUVA, KUNKKU, ÄSSÄ }

  public enum Maa  { RISTI, HERTTA, PATA, RUUTU }
  ...

      for (Maa maa : Maa.values())
        for (Arvo arvo : Arvo.values())
          System.out.println("" + maa + arvo);

Keskeytyslauseet break, continue ja return

• break-lause voi keskeyttää switch-, while-, do- tai for-lauseen

       while (jotakin) {
         ...
         if (keskeytyttää) 
           break;
         ...
       }
     

• continue-lauseella voidaan keskeyttää yksi toistokerta ja aloittaa seuraavan toiston alusta while-, do- ja for-lauseissa (tarkemmin: ohitetaan toistettavan alialgoritmin loppu ja siirrytään laskemaan toistoa kontrolloiva ehto, for-lauseessa siirrytään ensin laskemaan kasvatuslauseke)

  On kauniimpiakin tapoja tulostaa parittomat välillä 1-10 kuin seuraava:

       for (int i=1; i<10; ++i) {
          if (i%2 == 0)
            continue;
          System.out.println(i);
       } 
    

• Return-lauseella ilmaistaan "funktionkaltaisen" metodin palauttama arvo ja lopetaan metodin suoritus (return-lauseella ilman palautettavaa arvoa voi keskeyttää void-metodin suorituksen):

      public static boolean intToBool(int luku) {
        return luku != 0;
      }
     

  Return-lauseita voi olla metodissa useampiakin. Jokaisessa arvon palauttavassa metodissa on oltava ainakin yksi saavutettavissa oleva return-lause palautusarvoineen. Itse asiassa jokaisen mahdollisen algoritmin suortusreitin on päädyttävä return-lauseeseen!

  ulompi: while (jotakin) {
            int i = 1;
            ...
  sisempi:  while (jotain muuta) {
              int a = 1;
              ...
              if (meni vähän pieleen)
                break sisempi;
              ...
              if (kaikki meni pieleen)
                break ulompi;
              ...
            }
          }

Muita lauseita

Ns. rinnakkaisohjelmointia ("threadit") ja siihen liittyviä lauseita ei tällä kurssilla käsitellä.

Takaisin luvun 3 sisällysluetteloon.