9 Muuttuvat muuttujat

Olemassaolevan muuttujan arvoa halutaan usein muuttaa. Tämä onnistuu tavallisen sijoituslausekkeen avulla. Seuraavassa muuttujan ika arvoa kasvatetaan yhdellä:

int ika = 1;

System.out.println( ika );    // tulostuu 1
ika = ika + 1;                // ika:n uusi arvo on ika:n vanha arvo plus yksi
System.out.println( ika );    // tulostuu 2

Komento ika = ika + 1 siis kasvattaa muuttujan ika arvoa yhdellä. Muuttujan arvon kasvattaminen yhdellä onnistuu myös seuraavasti:

int ika = 1;

System.out.println( ika );    // tulostuu 1
ika++;                        // tarkoittaa samaa kuin ika = ika + 1;
System.out.println( ika );    // tulostuu 2

Toinen esimerkki:

int pituus = 100;

System.out.println( pituus );   // tulostuu 100
pituus = pituus - 50;
System.out.println( pituus );   // tulostuu 50
pituus = pituus * 2;
System.out.println( pituus );   // tulostuu 100
pituus = pituus / 4;
System.out.println( pituus );   // tulostuu 25
pituus--;                       // sama kuin pituus = pituus-1;
System.out.println( pituus );   // tulostuu 24

Scanner lukija = new Scanner(System.in);
int summa = 0;
int luettu;

// KIRJOITA OHJELMA TÄHÄN
// ÄLÄ KÄYTÄ MUITA MUUTTUJIA KUIN lukija, summa JA luettu!

System.out.println("Summa: "+summa);

Anna ensimmäinen luku: 3
Anna toinen luku: 6
Anna kolmas luku: 12

Summa: 21

Scanner lukija = new Scanner(System.in);

int summa = 0;
System.out.print("Anna lukuja, nolla lopettaa: ");
while (true) {
    int luettu = Integer.parseInt(lukija.nextLine());
    if (luettu == 0) {
        break;
    }

    // TEE JOTAIN TÄÄLLÄ

    System.out.println("Summa nyt: "+summa);
}
System.out.println("Summa lopussa: "+summa);

Anna lukuja, nolla lopettaa:
3
Summa nyt: 3
2
Summa nyt: 5
1
Summa nyt: 6
1
Summa nyt: 7
0
Summa lopussa: 7

10 Lisää toistoa

Opimme aiemmin toteuttamaan while(true)-komennon avulla ohjelman, joka toistaa tiettyä komentosarjaa komennon break suorittamiseen asti.

Komento break ei ole ainoa tapa lopettaa toistoa. Toistokomennon yleinen muoto on while (ehto), jossa ehtona voi olla mikä tahansa totuusarvoinen lauseke, eli ehto voi olla täsmälleen samaa muotoa kuin if-komentojen ehdot.

Seuraavassa esimerkissä tulostetaan luvut 1, 2, ..., 10. Kun luku-muuttuja saa arvokseen yli 10, while-ehto ei ole enää voimassa ja toistaminen lopetetaan.

int luku = 1;

while (luku < 11) {
    System.out.println(luku);
    luku++;    // luku++ tarkoittaa samaa kuin luku = luku + 1
}

Lue ylläoleva "niin pitkään kuin luku on pienempi kuin 11, tulosta luku ja kasvata lukua yhdellä".

Ylläolevassa koodissa ehdossa olevaa muuttujaa luku kasvatettiin jokaisella kierroksella yhdellä. Päivitys voi olla mikä tahansa, eli ehdossa olevan muuttujan ei tarvitse suinkaan aina kasvaa yhdellä, esim:

int luku = 1024;

while (luku >= 1) {
    System.out.println(luku);
    luku = luku / 2;
}

Screencast aiheesta:

1
2
3
(välissä paljon rivejä)
98
99
100

100
99
98
(välissä paljon rivejä)
3
2
1

2
4
6
(välissä paljon rivejä)
96
98
100

Mihin asti? 3
1
2
3

Mihin asti? 5
1
2
3
4
5

Mihin asti? 8
Mistä lähtien? 5
5
6
7
8

Mihin asti? 12
Mistä lähtien? 16

Montako ylös? 3

Montako ylös? 5
Montako alas? 3

10.1 Sijoitusoperaatiot

Koska vanhan muuttujan arvon muuttaminen on hyvin yleinen operaatio, on Javassa sitä varten erityiset sijoitusoperaatiot.

int pituus = 100;

pituus += 10;  // sama kuin pituus = pituus + 10;
pituus -= 50;  // sama kuin pituus = pituus - 50;

Olemassaolevan muuttujan arvoa muuttava sijoitusoperaatio merkitään muuttuja muutostyyppi= muutos, esimerkiksi muuttuja += 5. Huomaa, että muuttujan tyyppi pitää aina kertoa ennen kuin sille voidaan asettaa arvo. Muuttuja tulee siis aina esitellä ennen kuin se on käytettävissä. Muuttujan esittely tapahtuu kertomalla muuttujan tyyppi ja nimi.

Seuraava esimerkki ei toimi, sillä muuttujan pituus tyyppiä ei ole kerrottu.

pituus = pituus + 100;   // ei toimi!
pituus += 100;           // ei toimi!

Kun tyyppi on kerrottu, laskutkin toimivat oikein.

int pituus = 0;
pituus = pituus + 100;
pituus += 100;

// muuttujan pituus arvo on 200

Myös muille kuin yhteen- ja vähennyslaskuille on Javassa vastaavat sijoitusoperaatiot.

int pituus = 100;

pituus *= 10; // sama kuin pituus = 10 * pituus;
pituus /= 100; //sama kuin pituus = pituus / 100;
pituus %= 3;  // sama kuin pituus = pituus % 3;

// muuttujan pituus arvo 1

Usein ohjelmissa esiintyy toisto jonka aikana muuttujaan lasketaan jokin toistosta riippuvainen arvo. Seuraava ohjelma laskee tulon 4*3 hieman kömpelöllä tavalla eli summana 3+3+3+3:

int tulos = 0;

int i = 0;
while ( i < 4 ) {
    tulos = tulos + 3;
    i++;   // tarkoittaa samaa kuin i = i+1;
}

Alussa tulos = 0. Toistossa muuttujan arvo nousee joka kierroksella 3:lla. Ja koska toistoja on 4, on lopulta muuttujan arvona siis 3*4.

Käyttämällä yllä esiteltyä sijoitusoperaattoria, sama saadaan aikaan seuraavasti:

int tulos = 0;

int i = 0;
while ( i < 4 ) {
    tulos += 3;      // tämä on siis sama kuin tulos = tulos + 3;
    i++;             // tarkoittaa samaa kuin i = i+1;
}

Mihin asti? 3
Summa on 6

Mihin asti? 7
Summa on 28

Ensimmäinen: 3
Viimeinen: 5
Summa on 12

Ensimmäinen: 2
Viimeinen: 8
Summa on 35

Anna luku: 3
Kertoma on 6

Anna luku: 10
Kertoma on 3628800

Anna luku: 3
Tulos on 15

Anna luku: 7
Tulos on 255

10.2 Ikuinen silmukka

Yksi suosituimmista ohjelmointivirheistä toistolauseissa on tehdä vahingossa ikuinen silmukka. Seuraavassa yritetään tulostaa ruudulle 10 kertaa "En enää ikinä ohjelmoi ikuista silmukkaa":

int i = 0;

while( i<10 ) {
    System.out.println("En enää ikinä ohjelmoi ikuista silmukkaa");
}

Toistokertojen määrää kontrolloiva muuttuja i on aluksi 0 ja toistoja on tarkoitus tehdä niin kauan kuin i<10. Käy kuitenkin hieman hassusti: muuttujan i arvoa ei muuteta missään, joten toistoehto pysyy ikuisesti totena.

10.3 while ja lopetus

Olemme tehneet peräkkäin jo muutamia toistotehtäviä, joissa toistoehto on muotoa:

int i = 1;
while ( i < 10 ) {
    // ...
    i++;
}

Ylläolevassa rungossa muuttuja i muistaa toistokertojen määrän, ja lopetusehto perustuu i:n vertailuun.

Muistellaan taas toiston lopetusta. Toiston lopetuksen ei tarvitse perustua toistokertojen laskemiseen. Katsotaan esimerkkiä jossa kysytään käyttäjän ikää. Jos ikä ei ole välillä 1-120, annetaan huomautus ja kysytään ikä uudelleen. Toistolauseen while-lauseen ehto voi siis olla mitä tahansa totuusarvon tuottavaa.

System.out.println("ikäsi: ");

int ika = Integer.parseInt(lukija.nextLine());

while( ika < 1 || ika  > 120 ) {   // ikä pienempi kuin 5 TAI suurempi kuin 120
    System.out.println("Valehtelet");
    if ( ika < 1 ) {
        System.out.println("Olet niin nuori ettet osaa kirjoittaa");
    } else if ( ika > 120 ) {
        System.out.println("Olet niin vanha ettet osaa käyttää tietokonetta");
    }

    System.out.println("syötä ikäsi uudelleen: ");
    ika = Integer.parseInt(lukija.nextLine();
}

System.out.println("Ikäsi on siis "+ ika);

Ohjelman olisi voinut tehdä myös vanhaa tuttua while(true) -rakennetta käyttäen:

System.out.println("ikäsi: ");

while( true ) {
    int ika = Integer.parseInt(lukija.nextLine());

    if ( ika >= 1 && ika <= 120 ) {   // ikä 1:n JA 120:n välillä
        break;                              // lopetetaan toisto
    }

    System.out.println("Valehtelet");
    if ( ika < 1 ) {
        System.out.println("Olet niin nuori ettet osaa kirjoittaa");
    } else {  // ikä siis yli 120
        System.out.println("Olet niin vanha ettet osaa käyttää tietokonetta");
    }

    System.out.println("syötä ikäsi uudelleen: ");
}

System.out.println("Ikäsi on siis "+ ika);

Syötä luvut:
5
2
4
-1
Kiitos ja näkemiin!

Syötä luvut:
5
2
4
-1
Kiitos ja näkemiin!
Summa: 11

Syötä luvut:
5
2
4
-1
Kiitos ja näkemiin!
Summa: 11
Lukuja: 3

Syötä luvut:
5
2
4
-1
Kiitos ja näkemiin!
Summa: 11
Lukuja: 3
Keskiarvo: 3.666666666666

Syötä luvut:
5
2
4
-1
Kiitos ja näkemiin!
Summa: 11
Lukuja: 3
Keskiarvo: 3.666666666666
Parillisia: 2
Parittomia: 1

int i = 0;
while ( i < 10 ) {
    System.out.println( i );
    i++;
}

for ( int i = 0; i < 10 ; i ++ ) {
    System.out.println( i );
}

11 Metodit

Olemme käyttäneet useita erilaisia komentoja Javassa: sijoitusta, laskutoimituksia, vertailuja, if:iä ja whileä. Ruudulle tulostaminen on tehty "komentoa" System.out.println() käyttäen. Kahden luvun maksimi osataan laskea "komennolla" Math.max(). Tuttuja ovat myös lukija.nextLine() ja sen kanssa usein nähty Integer.parseInt().

Huomaamme, että jälkimmäinen joukko edellä lueteltuja komentoja poikkeaa if:istä ja while:stä ym. siinä, että komennon perässä on sulut ja joskus sulkujen sisällä komennolle annettava syöte. "Sulkuihin päättyvät" eivät oikeastaan olekaan komentoja vaan metodeja.

Teknisesti ottaen metodi tarkoittaa koodinpätkää, jota voi kutsua muualta ohjelmakoodista. Koodirivi System.out.println("olen metodille annettava parametri!") siis tarkoittaa, että kutsutaan metodia, joka suorittaa ruudulle tulostamisen. Metodin suorituksen jälkeen palataan siihen kohtaa missä ennen metodikutsua oltiin menossa. Metodille suluissa annettua syötettä kutsutaan metodin parametriksi.

Parametrin lisäksi metodilla voi olla paluuarvo. Esim. tuttu koodinpätkä:

int luku = Integer.parseInt( lukija.nextLine() );

sisältää kaksi metodikutsua. Ensin kutsutaan sisempänä olevaa metodia lukija.nextLine. Metodilla on paluuarvonaan käyttäjän syöttämä merkkijono. Seuraavaksi kutsutaan metodia Integer.parseInt. Metodikutsun parametrina on merkkijono jonka lukija.nextLine:n kutsu palautti ja metodin paluuarvona on merkkijonoa vastaava kokonaisluku.

Metodin nimeen näyttää liittyvän piste, esim. lukija.nextLine(). Oikeastaan tässä metodin nimi onkin pisteen oikeanpuoleinen osa, eli nextLine(). Pisteen vasemmanpuoleinen osa, eli tässä lukija kertoo kenen metodista on kyse. Eli kyseessä on lukijan metodi nextLine. Opimme hiukan myöhemmin tarkemmin mistä tässä pisteen vasemmanpuoleisessa osassa on kyse. Tarkka lukija tietysti huomaa, että System.out.println():ssa on "kaksi pistettä". Metodin nimi tässä on println, ja System.out on se kenen metodista on kyse. Karkeasti ottaen System.out tarkoittaa koneen näyttöä.

Tähän mennessä käyttämämme metodit ovat kaikki olleet Javan valmiita metodeita. Nyt opettelemme tekemään omia metodeita.

12 Omat metodit

Olemme tähän mennessä ohjelmoineet ohjelmamme siten, että kaikki tapahtuu yhdessä jatkumossa ja koodia luetaan ylhäältä alas.

Edellä mainittiin että "metodi tarkoittaa koodinpätkää, jota voi kutsua muualta ohjelmakoodista". Javan valmiita metodeja on käytetty jo oikeastaan ensimmäisestä ohjelmasta lähtien.

Javan valmiiden metodien käytön lisäksi ohjelmoija voi kirjoittaa itse metodeja joita sovellus kutsuu. Oikeastaan on hyvin poikkeuksellista jos ohjelmassa ei ole yhtään itse kirjoitettua metodia. Tästälähtien lähes jokainen kurssilla tehty ohjelma sisältääkin itsekirjoitettuja metodeja.

Ohjelmarunkoon metodit kirjoitetaan main:in aaltosulkeiden ulkopuolelle mutta kuitenkin "uloimmaisten" aaltosulkeiden sisäpuolelle, joko mainin ylä- tai alapuolelle

import java.util.Scanner;

public class OhjelmaRunko {
    // omia metodeja tänne

    public static void main(String[] args) {
        Scanner lukija = new Scanner(System.in);
        // ohjelmakoodi
    }

    // omia metodeja tai tänne
}

Luodaan metodi tervehdi.

public static void tervehdi() {
    System.out.println("Terveiset metodimaailmasta!");
}

Ja asetetaan se metodeille kuuluvalle paikalle.

import java.util.Scanner;

public class OhjelmaRunko {
    public static void main(String[] args) {
        Scanner lukija = new Scanner(System.in);
        // ohjelmakoodi
    }

    // omat metodit
    public static void tervehdi() {
        System.out.println("Terveiset metodimaailmasta!");
    }
}

Metodin määrittely sisältää kaksi osaa. Metodimäärittelyn ensimmäisellä rivillä on metodin nimi eli tervehdi. Nimen vasemmalla puolella tässä vaiheessa määreet public static void. Metodin nimen sisältävän rivin alla on aaltosulkeilla erotettu koodilohko, jonka sisälle kirjoitetaan metodin koodi, eli ne komennot jotka metodia kutsuttaessa suoritetaan. Metodimme tervehdi ei tee muuta kuin kirjoittaa rivillisen tekstiä ruudulle.

Itsekirjoitetun metodin kutsu on helppoa, kirjoitetaan metodin nimi ja perään sulut ja puolipiste. Seuraavassa main eli pääohjelma kutsuu metodia ensin kerran ja sen jälkeen useita kertoja.

import java.util.Scanner;

public class OhjelmaRunko {
    public static void main(String[] args) {
        Scanner lukija = new Scanner(System.in);

        // ohjelmakoodi
        System.out.println("Kokeillaan pääsemmekö metodimaailmaan:");
        tervehdi();

        System.out.println("Näyttää siltä, kokeillaan vielä:");
        tervehdi();
        tervehdi();
        tervehdi();
    }

    // omat metodit
    public static void tervehdi() {
        System.out.println("Terveiset metodimaailmasta!");
    }
}

Ohjelman suoritus saa aikaan seuraavan tulosteen:

Kokeillaan pääsemmekö metodimaailmaan:
Terveiset metodimaailmasta!
Näyttää siltä, kokeillaan vielä:
Terveiset metodimaailmasta!
Terveiset metodimaailmasta!
Terveiset metodimaailmasta!

Huomionarvoista tässä on koodin suoritusjärjestys. Koodin suoritus etenee siten, että pääohjelman -- eli main:in -- rivit suoritetaan ylhäältä alas yksi kerrallaan. Koodirivin ollessa metodikutsu, mennään suorittamaan metodin koodirivit, jonka jälkeen palataan kohtaan, josta metodin kutsu tapahtui. Tarkemmin ottaen metodikutsun jälkeiselle riville.

Jos ollaan tarkkoja on pääohjelma eli main itsekin metodi. Kun ohjelma käynnistyy, kutsuu käyttöjärjestelmä main:ia. Metodi main on siis ohjelman käynnistyspiste, jonka ylimmältä riviltä ohjelman suoritus lähtee liikkeelle. Ohjelman suoritus loppuu kun päädytään mainin loppuun.

Jatkossa kun esittelemme metodeja, emme erikseen mainitse että niiden täytyy sijaita omalla paikallaan. Metodia ei esimerkiksi voi määritellä toisen metodin sisällä.

public static void main(String[] args) {
    tulostaTeksti();
}

public static void tulostaTeksti() {
    // kirjoita koodia tähän
}

Alussa olivat suo, kuokka ja Java.

public static void main(String[] args) {
    // kysy käyttäjältä, montako kertaa teksti tulostetaan
    // kutsu metodia tulostaTeksti while-komennon avulla useita kertoja
}

public static void tulostaTeksti() {
    // kirjoita koodia tähän
}

Kuinka monta?
7
Alussa olivat suo, kuokka ja Java.
Alussa olivat suo, kuokka ja Java.
Alussa olivat suo, kuokka ja Java.
Alussa olivat suo, kuokka ja Java.
Alussa olivat suo, kuokka ja Java.
Alussa olivat suo, kuokka ja Java.
Alussa olivat suo, kuokka ja Java.

12.1 Metodin parametrit

Metodista saa huomattavasti monikäyttöisemmän antamalla sille parametreja. Parametrit ovat muuttujia, jotka määritellään metodin ylimmällä rivillä metodin nimen jälkeen olevien sulkujen sisällä. Kun metodia kutsutaan, sen parametreille annetaan arvot kutsuvaiheessa.

Seuraavassa esimerkissä määritellään parametrillinen metodi tervehdi, jolla on String-tyyppinen parametri nimi.

public static void tervehdi(String nimi) {
    System.out.println("Hei " + nimi + ", terveiset metodimaailmasta!");
}

Kutsutaan metodia tervehdi siten, että parametrin nimi arvoksi asetetaan ensimmäisellä kutsulla Matti ja toisella kutsulla Arto.

public static void main(String[] args) {
    tervehdi("Matti");
    tervehdi("Arto");
}

Hei Matti, terveiset metodimaailmasta!
Hei Arto, terveiset metodimaailmasta!

Aivan kuten kutsuttaessa Javan valmista System.out.println()-metodia, voi oman metodin kutsussa parametrina käyttää monimutkaisempaa ilmausta:

public static void main(String[] args) {
    String nimi1 = "Antti";
    String nimi2 = "Mikkola";
    tervehdi( nimi1 + " " + nimi2 );

    int ika = 24;
    tervehdi("Juhana " + ika + " vuotta");
}

Hei Antti Mikkola, terveiset metodimaailmasta!
Hei Juhana 24 vuotta, terveiset metodimaailmasta!

Molemmissa tapauksissa metodilla on edelleen vain 1 parametri. Parametrin arvo lasketaan ennen metodin kutsumista. Ensimmäisessä tapauksessa parametrin arvo saadaan merkkijonokatenaationa nimi1 + " " + nimi2 joka siis on arvoltaan Antti Mikkola ja jälkimmäisessä tapauksessa merkkijonokatenaatiosta "Juhana " + ika + " vuotta".

12.2 Monta parametria

Metodille voidaan määritellä useita parametreja. Tällöin metodin kutsussa parametrit annetaan samassa järjestyksessä.

public static void tervehdi(String nimi, String mistaTerveiset) {
    System.out.println("Hei " + nimi + ", terveiset " + mistaTerveiset);
}

String kuka = "Matti";
String terveiset = "Kyröjoelta";

tervehdi(kuka, terveiset);
tervehdi(kuka, terveiset + " ja Kumpulasta");

Jälkimmäisessä tervehdi-funktion kutsussa toinen parametri muodostetaan katenoimalla muuttujaan terveiset teksti " ja Kumpulasta". Tämä suoritetaan ennen varsinaista funktion suoritusta.

Hei Matti, terveiset Kyröjoelta
Hei Matti, terveiset Kyröjoelta ja Kumpulasta

12.3 Metodi kutsuu toista metodia

main ei ole suinkaan ainoa joka voi kutsua metodeita. Metodit voivat kutsua myös toisiaan. Tehdään metodi tervehdiMontaKertaa, joka tervehtii käyttäjää useasti metodin tervehdi avulla:

public static void tervehdi(String nimi) {
    System.out.println("Hei " + nimi + ", terveiset metodimaailmasta!");
}

public static void tervehdiMontaKertaa(String nimi, int kerrat) {
    int i = 0;
    while ( i < kerrat ) {
        tervehdi(nimi);
        i++;
    }

}

public static void main(String[] args) {
    tervehdiMontaKertaa("Antti", 3);
    System.out.println("ja");
    tervehdiMontaKertaa("Martin", 2);
}

Tulostuu:

Hei Antti, terveiset metodimaailmasta!
Hei Antti, terveiset metodimaailmasta!
Hei Antti, terveiset metodimaailmasta!
ja
Hei Martin, terveiset metodimaailmasta!
Hei Martin, terveiset metodimaailmasta!

Screencast aiheesta:

private static void tulostaTahtia(int maara) {
    // yhden tähden saat tulostettua komennolla
    // System.out.print("*");
    // kutsu tulostuskomentoa n kertaa
    // tulosta lopuksi rivinvaihto komennolla
    // System.out.println("");
}

public static void main(String[] args) {
    tulostaTahtia(5);
    tulostaTahtia(3);
    tulostaTahtia(9);
}

*****
***
*********

****
****
****
****

*****************
*****************
*****************

*
**
***
****

   *
  **
 ***
****

   *
  ***
 *****
*******
  ***
  ***

         *
        ***
       *****
      *******
     *********
    ***********
   *************
  ***************
 *****************
*******************
        ***
        ***

Arvaa luku: 73
Luku on pienempi, tehtyjä arvauksia: 1
Arvaa luku: 22
Luku on suurempi, tehtyjä arvauksia: 2
Arvaa luku: 51
Luku on suurempi, tehtyjä arvauksia: 3
Arvaa luku: 62
Luku on suurempi, tehtyjä arvauksia: 4
Arvaa luku: 68
Luku on suurempi, tehtyjä arvauksia: 5
Arvaa luku: 71
Luku on pienempi, tehtyjä arvauksia: 6
Arvaa luku: 70
Onneksi olkoon, oikein arvattu!

Arvaa luku: 12
Luku on suurempi

Arvaa luku: 66
Luku on pienempi

Arvaa luku: 42
Onneksi olkoon, oikein arvattu!

Arvaa luku: 55
Luku on suurempi
Arvaa luku: 85
Luku on pienempi
Arvaa luku: 77
Luku on suurempi
Arvaa luku: 81
Luku on suurempi
Arvaa luku: 83
Onneksi olkoon, oikein arvattu!

Arvaa luku: 55
Luku on suurempi, tehtyjä arvauksia: 1
Arvaa luku: 85
Luku on pienempi, tehtyjä arvauksia: 2
Arvaa luku: 77
Luku on suurempi, tehtyjä arvauksia: 3
Arvaa luku: 81
Luku on suurempi, tehtyjä arvauksia: 4
Arvaa luku: 83
Onneksi olkoon, oikein arvattu!