int a = 1;
int b = 2;
a = 3;

int r = 2;
int s = 4;
r = s;

int p = 1;
int q = 8;
q = p;
p = q;

int x = 7;
int y = 5;
int z = 0;
z = x;
x = y;
y = z;

c = a;
a = b;
b = c;

j = i;
i = k;
k = j;

9 Uusia tehtävätyyppejä!

Viikosta 2 eteenpäin materiaalissa on ohjelmointitehtävien lisäksi koodinluku- ja selitystehtäviä. Toisin kuin ohjelmointitehtävät, koodinluku- ja selitystehtävät eivät vaikuta kurssipisteisiin, eli kurssilla etenemisen kannalta niiden tekeminen on vapaaehtoista. Tehtävistä on kuitenkin hyötyä sekä kertaamisessa että kurssin aihepiiriin liittyvien "knoppien" ymmärtämisessä, joten niiden tekeminen on suositeltavaa.

9.1 Koodinlukutehtävät

Alla on kaksi esimerkkiä koodinlukutehtävästä. Kun avaat koodinlukutehtävän sitä klikkaamalla, huomaat että tehtävään liittyy sekä "Tarkista vastaus"-nappi että "Uusi tehtävä"-nappi. Uusi tehtävä -napin avulla voit hakea itsellesi uuden samaan teemaan liittyvän koodinlukutehtävän. Kokeile!

9.2 Selitystehtävät

Selitystehtävät ovat taas tehtäviä, missä kirjoitat tehtävässä esitettyyn ongelmaan liittyvän vastauksen. Tehtävänanto kertoo mitä pitää tehdä. Selitysten ei tarvitse olla kovin pitkiä, mutta kuitenkin sellaisia, että kurssikaverisi ymmärtää mistä on kyse -- tulet myöhemmin kurssilla myös lukemaan ja pohtimaan muiden selityksiä. Voit testata allaolevaa selitystehtävää.

10 Muuttuvat muuttujat

Kurssin ensimmäisen viikon oleellisimmat opittavat asiat liittyivät muuttujien ja toistolauseiden käyttöön. Jatketaan samalla teemalla.

Muuttujia käytetään tiedon säilyttämiseen sekä tiedon myöhempään noutamiseen. Muuttujan esittely tapahtui kertomalla ensin muuttujan tyyppi, esimerkiksi kokonaisluku (int), jota seuraa muuttujan nimi, esimerkiksi luku -- yhdessä int luku. Muuttujan esittelyä seuraa tyypillisesti sijoitusoperaatio, minkä avulla muuttujalle asetetaan arvo, esimerkiksi int luku = 5 luo kokonaislukumuuttujan nimeltä luku ja asettaa siihen arvon 5.

Muuttujan arvoa voi käyttää myös uuden muuttujan esittelyssä ja arvon asetuksessa. Alla olevassa koodissa luodaan ensin muuttuja nimeltä pituus, jonka jälkeen luodaan muuttuja paino. Muuttujaan paino asetetaan puolet muuttujan pituus arvosta.

int pituus = 180;
int paino = pituus / 2;

System.out.println(paino);

90

Olemassaolevan muuttujan arvoa voidaan muuttaa. Tämä onnistuu sijoituslausekkeen avulla. Seuraavassa esitellään ensin muuttuja ika, jolle asetetaan alkuarvoksi 1. Tämän jälkeen muuttujan ika arvoa kasvatetaan yhdellä:

int ika = 1;

System.out.println(ika);
ika = ika + 1;    // muuttujan ika uusi arvo on ika-muuttujan vanha arvo plus yksi
System.out.println(ika);

Tulostuu:

1
2

Tarkastellaan rivin ika = ika + 1; suoritusta vielä tarkemmin. Komento ika = ika + 1; kasvattaa muuttujan ika arvoa yhdellä. Käytännössä komennon suoritus tapahtuu siten, että ensin suoritetaan yhtäsuuruusmerkin oikealla puolella oleva lause ika + 1. Tässä tietokone etsii ensin muuttujaa ika. Koska muuttuja on esitelty aiemmin koodissa, se löytyy (sen arvo on 1). Lauseen ika + 1 muuttujan ika paikalle asetetaan arvo 1. Lause on nyt muotoa 1 + 1, jonka tietokone osaa laskea: tulokseksi tulee 2. Komento on tämän jälkeen kokonaisuudessaan ika = 2, mikä tarkoittaa "aseta muuttujan ika arvoksi 2".

Muuttujan arvon kasvattaminen yhdellä onnistuu myös seuraavasti:

int ika = 1;

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

Komento ika++ muuntuu ohjelmaa suoritettaessa muotoon ika = ika + 1;. Ohjelman tulostus on sama kuin edellisessä:

1
2

Toinen esimerkki:

int pituus = 100;

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

Tulostuu:

100
50
100
25
24

10.1 Syötteen lukeminen

Kuten edellisellä viikolla huomasimme, näppäimistöltä voidaan lukea käyttäjän antamaa syötettä Scanner-apuvälineen avulla:

Scanner lukija = new Scanner(System.in);
int pituus = 100;

System.out.println(pituus);

System.out.print("Paljonko poistetaan? ");
pituus = pituus - Integer.parseInt(lukija.nextLine());
System.out.println(pituus);

System.out.print("Paljonko lisätään? ");
pituus = pituus + Integer.parseInt(lukija.nextLine());
System.out.println(pituus);

Tulostus esimerkiksi:

100
Paljonko poistetaan? 42
58
Paljonko lisätään? 1
59

Tarkastellaan rivin pituus = pituus - Integer.parseInt(lukija.nextLine()); suoritusta vielä tarkemmin.

Rivi on asetuslause, missä muuttujaan pituus asetetaan lauseen pituus - Integer.parseInt(lukija.nextLine()) tuottama arvo. Lause pituus - Integer.parseInt(lukija.nextLine()) suoritetaan seuraavasti:

1. Tietokone etsii ensin muuttujan pituus arvon. Koska muuttuja on luotu aiemmin, se löytyy: sen arvo on 100. Nyt lasku on muotoa 100 - Integer.parseInt(lukija.nextLine());.
2. Tietokone suorittaa lauseen Integer.parseInt(lukija.nextLine()):
   1. Ensin Suoritetaan sulkujen sisällä oleva osa, eli lukija.nextLine(). Tämä johtaa siihen, että ohjelma jää odottamaan käyttäjältä syötettä. Kun käyttäjä antaa syötteen, esimerkiksi "42", vaihtuu komennon lukija.nextLine() paikalle käyttäjän syöttämä merkkijono. Seuraavaksi suoritettava komento on nyt Integer.parseInt("42");.
   2. Komento Integer.parseInt("42") muuttaa tekstimuuttujan, jonka arvo on "42", kokonaislukumuuttujaksi, jonka arvo on 42.
3. Lauseen Integer.parseInt(lukija.nextLine()) paikalle asetetaan sen suorituksesta saatu arvo, tässä 42. Nyt lasku on muotoa 100 - 42.
4. Tietokone laskee laskun 100 - 42, jonka tulos on 58.

Lopulta lause on muotoa pituus = 58, eli muuttujan pituus arvoksi asetetaan 58.

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.2 Sijoitusoperaatiot

Koska olemassaolevan muuttujan arvon muuttaminen on hyvin yleinen operaatio, on sitä varten olemassa 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 tulee olla olemassa 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ä muuttujaa leveys ei ole esitelty.

leveys += 100;           // ei toimi!

Kun muuttuja on esitelty, laskukin toimii oikein.

int leveys = 100;  // muuttujan esittely; "on olemassa int-tyyppinen muuttuja nimeltä leveys, jonka arvo on 100"
leveys += 100;     // toimii!

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

int pituus = 100;
System.out.println(pituus);

pituus *= 10; // sama kuin pituus = pituus * 10;
System.out.println(pituus);

pituus /= 100; // sama kuin pituus = pituus / 100;
System.out.println(pituus);

pituus %= 3; // sama kuin pituus = pituus % 3;
System.out.println(pituus);

100
1000
10
1

10.3 Muuttujien olemassaolo

Kun muuttuja esitellään, se ei ole kaikkialla olemassa. Muuttujan olemassaoloon liittyy oleellisesti kaksi sääntöä:

1. Muuttujaa ei ole olemassa ennen sen esittelyä, eikä sitä voi käyttää ennen kuin se on esitelty.

   if (luku > 10) { // ei toimi sillä muuttujaa luku ei vielä tunneta!
       System.out.println("Jee!");
   }
   
   int luku = 12;
   

   int luku = 12;
   
   if (luku > 10) { // toimii!
       System.out.println("Jee!");
   }
   

2. Muuttuja on näkyvissä vain niiden aaltosulkujen sisällä kuin missä se on esitelty, eikä siihen pääse käsiksi aaltosulkujen ulkopuolelta. Esimerkiksi, jos if- tai while-komentoon liittyvässä lohkossa (aaltosuluilla rajattu alue) esitellään muuttuja, muuttuja on käytössä vain aaltosulkujen sisällä.

   int luku = 12;
   
   if (luku > 10) {
       System.out.println("Jee!");
       int tulostus = 52;
   }
   
   System.out.println(tulostus); // ei toimi sillä muuttuja tulostus on olemassa vain if-lauseen lohkojen sisällä.
   

   int luku = 12;
   int tulostus = 0;
   
   if (luku > 10) {
       System.out.println("Jee!");
       tulostus = 52;
   }
   
   System.out.println(tulostus); // toimii!
   

Toisen säännön yhteydessä myös ensimmäinen sääntö pätee. Muuttuja on olemassa vain sen esittelyhetkestä eteenpäin, ei koskaan ennen esittelyhetkeä.

11 Lisää toistoa

Opimme edellisellä viikolla (kts. Toiston alkeet) toteuttamaan while (true)-komennon avulla ohjelman, joka toistaa tiettyä komentosarjaa komennon break suorittamiseen asti. Kerrataanpa tätä hieman:

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, ..., 5. Kun luku-muuttujan arvo on yli 5, while-ehto ei ole enää voimassa ja toistaminen lopetetaan.

int luku = 1;

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

Lue ylläoleva "niin pitkään kuin muuttujan luku arvo on pienempi kuin 6, tulosta muuttujan luku arvo ja kasvata muuttujan luku arvoa 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 /= 2; // luku /= 2 tarkoittaa samaa kuin 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

11.1 Milloin toisto loppuu?

Tarkastellaan seuraavaa toistolausetta.

int luku = 1;

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

Ohjelman tulostus seuraavanlainen:

1
2
1
2
1
2
...

Vaikka muuttujan luku arvo on välillä 2, toistolauseen suoritus ei lopu koskaan.

Toistolauseen ehto tarkistetaan vain kun toistolauseen toistaminen aloitetaan sekä silloin kun koodin suoritus on päässyt toistolauseen lopettavaan aaltosulkuun asti. Jos ehto on totta, suoritus hyppää takaisin toistolauseen alkuun, ja jos ehto on epätotta, suoritus jatkuu toistolausetta seuraavalta riviltä.

Vaikka muuttujan luku arvo on ylläolevassa toistolauseessa välillä 2, ei se ole koskaan 2 toistolauseen lopussa. Lopussa ehto luku != 2 on aina totta, ja suoritus hyppää takaisin koodin alkuun.

11.2 Toisto ja useampi muuttuja

Usein ohjelmissa esiintyy toisto, jonka jokaisella toistokerralla muutetaan yhden tai useamman muuttujan arvoa. 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 += 3; // tarkoittaa samaa kuin tulos = tulos + 3;
    i++;  // tarkoittaa samaa kuin i = i + 1;
}

System.out.println(tulos);

Alussa tulos = 0. Toiston jokaisella kierroksella muuttujan tulos arvoon lisätään luku 3. Koska toistoja on 4, on lopulta muuttujan arvona 3 * 4 eli 12, jonka ohjelma lopulta tulostaa.

Yksi näppärä tapa muuttujien arvojen tarkasteluun toistolauseessa on taulukko. Seuraavaan taulukkoon on kirjoitettu auki edellä olevassa ohjelmassa olevien muuttujien tulos ja i arvot kullakin toistolauseen ehdon i < 4 vertailuhetkellä.

Toistolauseen suoritus loppuu kun muuttujan summa arvo on 12 ja muuttujan i arvo on 4 (ehto i < 4 on tällöin epätotta).

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

11.3 Ikuinen silmukka

Yksi suosituimmista toistolauseisiin liittyvistä ohjelmointivirheistä on vahingossa tehty ikuinen silmukka. Seuraavassa yritetään tulostaa ruudulle 3 kertaa "En enää ikinä ohjelmoi ikuista silmukkaa":

int i = 0;

while (i < 3) {
    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 ehto i < 3 on totta. Käy kuitenkin hieman hassusti: muuttujan i arvoa ei muuteta toistolauseessa, joten toistoehto pysyy ikuisesti totena.

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

11.4 Toiston lopetuksen ei tarvitse perustua toistokertojen laskemiseen

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

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

Ylläolevassa rungossa muuttujaa i käytetään toistokertojen määrän muistamiseen, ja lopetusehto perustuu vertailuun i < 10.

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 1 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: ");

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

while (true) {

    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: ");
    ika = Integer.parseInt(lukija.nextLine());
}

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

11.5 Lisätietoa: Toisto for-lauseen avulla

Edellä esitellyn while-toistolauseen lisäksi Javassa toiston voi hoitaa myös for-toistolauseen avulla. Varsinaisesti rupeamme käyttämään for-toistolausetta vasta hieman myöhemmin kurssilla, mutta jo tässä vaiheessa mainittakoon, että while-toistolauseen voi toteuttaa myös toisella tavalla.

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

Edellinen while-toistolause tehtäisiin for-toistolauseen avulla seuraavasti:

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

For-toistolause sisältää samalla rivillä indeksimuuttujan alustuksen (int i = 0;), toistoehton (i < 10;) ja indeksimuuttujan (i++) kasvatuksen puolipistein eroteltuna.