Johdanto

Ohjelmointi on nykyajan käsityöläistaito ja ohjelmointia työkseen tai harrastuksekseen tekevien määrä on jatkuvasti kasvussa. Ohjelmistojen ja ohjelmien lähdekoodin tallentamispalvelua tarjoava GitHub arvioi vuonna 2016 palvelun käyttäjien määräksi yli 20 miljoonaa, mutta -- koska kaikki ohjelmoijat eivät käytä kyseistä palvelua -- ohjelmoijia on todennäköisesti hyvin paljon enemmän. Tämän modernin käsityöläistaidon tarve työelämässä on akuutti -- esimerkiksi Tivi uutisoi 2016 aiheesta otsikolla "It-osaaja pääsee töihin vaikka heti". Samalla tiede perustuu yhä enemmän datan analyysissä käytettäviin ohjelmistoihin sekä ohjelmistoalan innovaatioihin. Esimerkiksi meteorologit, fyysikot ja kemistit käyttävät ohjelmistoja ja ohjelmoivat työssään. Myös kasvatustiede ja opetusala yleisemmin hyödyntää yhä enemmän digitalisaation tuomia mahdollisuuksia.

Ohjelmoinnin opettelua harkitseva tietää harvoin mikä kaikki yhteiskunnassamme nojautuu ohjelmoijien tuottamiin ohjelmistoihin. Ilman ohjelmointia yhteydenpito, kaupankäynti, matkustaminen, terveydenhuolto ja niin edelleen olisivat yksinkertaisesti heikommalla tasolla. Puhelimet eivät toimisi, verkkopankkeja saatikka pankki- ja luottokortteja ei olisi, matkojen varaaminen ja henkilöasiakirjojen käyttäminen ei onnistuisi verkon yli, lääketeollisuus ei pystyisi käymään suuria massoja dataa läpi parannuskeinoja etsimisessä, tiedon hakeminen tapahtuisi sana- ja tietokirjoista ja niin edelleen. Margaret Hamilton ei olisi myöskään koskaan kirjoittanut ihmisiä kuuhun vienyttä ohjelmaa.

Tällä kurssilla otat ensiaskeleet ohjelmointiin. Opit kirjoittamaan ohjelmia ja ymmärtämään niiden toimintaa. Kurssin jälkeen katsot yhteiskunnan palveluita myös ohjelmoijan näkökulmasta ja tiedät, että palvelut toimivat (tai ovat rikki!) ohjelmistojen ansiosta.

Ohjelma ja lähdekoodi

Ohjelma on järjestetty joukko käskyjä, joita tietokone noudattaa yksi kerrallaan.

Nykypäivänä ohjelmoijat eivät ohjelmoi tietokoneen noudattamaksi tarkoitettuja käskyjä käyttäen. Ohjelmoinnissa käytetään ihmisen kirjoitettavaksi ja luettavaksi tarkoitettua ohjelmointikieltä, kuten tällä kurssilla käytettyä Javaa. Ohjelmoijan kirjoittamaa ohjelmakoodia kutsutaan lähdekoodiksi. Lähdekoodi käännetään ohjelmointikielen- ja ohjelmointiympäristön tarjoamien työvälineiden avulla konekieliseksi ohjelmaksi, jonka käskyjä tietokone noudattaa.

Lähdekoodi koostuu lauseista (statement) ja lausekkeista (expression), joita Java-kielessä voidaan lukea rivi riviltä ylhäältä alaspäin ja vasemmalta oikealle. Esimerkiksi tekstin "Hei maailma" tulostuksessa käytetään Java-ohjelmointikielellä lausetta:

System.out.println("Hei maailma");

Lause System.out.println on Java-ohjelmointikielen valmiiksi tarjoama komento, jota käytetään merkkijonon tulostamiseen. Komento käytännössä käskee tietokonetta tulostamaan sille sulkeiden sisällä hipsuissa annetun merkkijonon. Komennon pääte ln on lyhenne sanasta line, eli komentoa käyttämällä merkkijonon jälkeen tulostetaan myös rivinvaihto.

Lauseen loppuun kirjoitetaan puolipiste ;.

Ohjelmarunko

Java-ohjelmat vaativat toimiakseen kurssin aikana tutuksi tulevan rungon. Ohjelman runko on seuraavanlainen.

public class Esimerkki {
    public static void main(String[] args) {

        // Tänne kirjoitetaan ohjelman käyttämät lauseet
        System.out.println("Tulostettava teksti");

    }
}

Ohjelmoidessa yhdenkin merkin puuttuminen voi johtaa virhetilanteeseen. Ohjelmoija saattaa vahingossa esimerkiksi syöttää pilkun pisteen sijaan, kirjoittaa vaikkapa printin sanan println sijaan, tai jättää tulostettavasta merkkijonosta hipsut pois. Jokainen em. virheistä johtaa tilanteeseen, missä ohjelman suoritus ei onnistu.

Ohjelmarunko sisältää Java-ohjelmointikielelle oleellisia osia. Eri ohjelmointikielillä on erilainen ohjelmarunko. Tulemme myöhemmin tutustumaan tarkemmin sanojen public class ja public static void merkitykseen.

Ohjelman suoritus alkaa riviä public static void main(String[] args) { seuraavalta riviltä ja päättyy sulkevaan aaltosulkuun }. Lauseet suoritetaan yksi kerrallaan. Tällä hetkellä ainoa suoritettava lause on System.out.println("Tulostettava teksti");, mikä tulostaa tekstin "Tulostettava teksti".

Jatkossa materiaalin esimerkeissä ei aina erikseen näytetä ohjelmarunkoa, mutta voit olettaa, että se tarvitaan.

Alla on kurssin ensimmäinen ohjelmointitehtävä. Ohjelmointitehtävät tehdään kurssilla käytössä olevassa Test My Code -ohjelmointiympäristössä, mutta tehtävänannot ovat kurssimateriaalissa. Saat tehtävänannon auki klikkaamalla alla olevaa otsikkoa "Ada Lovelace":

public class Nimi {

    public static void main(String[] args) {
        // Kirjoita ohjelmasi tähän alle

    }
}

Ada Lovelace

Ohjelman osia

Kommentit

Lähdekoodia voi kommentoida selkeyttääkseen sitä tai lisätäkseen muistiinpanoja kahdella eri tavalla.

• Yhden rivin kommentit aloitetaan kahdella vinoviivalla, //. Kaikki kahta vinoviivaa seuraava samalla rivillä oleva teksti tulkitaan kommentiksi.
• Useamman rivin kommentit aloitetaan yhdellä vinoviivalla ja tähdellä /* ja lopetetaan tähdellä ja vinoviivalla */. Kaikki useamman rivin kommentin aloittavan ja lopettavan alueen välillä tulkitaan kommentiksi.

Alla on esimerkki ohjelmasta, jossa kumpikin kommenttityyppi on käytössä.

public class Kommentteja {
    public static void main(String[] args) {

        // Tulostetaan
        System.out.println("Tulostettava teksti");
        System.out.println("Lisää tulostettavaa!");

        /*
        Seuraavaksi:
         - lisää tulostamisesta
         - lisää harjoittelua
         - muuttujat
         - ...
        */

        // System.out.println("Muuta tulostettavaa");
    }
}

Esimerkin alin rivi esittelee erityisen kätevän käyttökohteen kommenteille. Kirjoitettua lähdekoodia ei tarvitse poistaa jos haluaa tilapäisesti kokeilla jotain.

Hei Maailma!
(Ja Mualima!)

Tulostaminen

Käytimme edellä lausetta System.out.println("tulostettava"); merkkijonon tulostamiseen. Tulostuslause tulostaa sekä hipsuissa olevan merkkijonon että rivinvaihdon. Jos haluaa tulostaa merkkijonon ilman rivinvaihtoa, käytetään komentoa System.out.print("tulostettava");.

Yhteenvetona: tulostamiseen on kaksi lausetta:

• System.out.println("sana"); tulostaa tekstin "sana" ja loppurivinvaihdon
• System.out.print("sana"); tulostaa tekstin "sana" ilman loppurivinvaihtoa

Tulostettavan tekstin osana voi olla myös erikoismerkkejä, joista tärkein on rivinvaihto. Rivinvaihto ilmaistaan kenoviivalla ja n-merkillä seuraavasti: \n. Erikoismerkkejä on muitakin.

System.out.println("Ensimmäinen\nToinen\nKolmas");

Yllä oleva lause tulostaa seuraavaa:

Ensimmäinen
Toinen
Kolmas

Komennon parametrit

Tulostuslauseen tulostama tieto eli komennon parametrit annetaan tulostuskomennolle lisäämällä ne lauseen perässä olevien sulkujen () sisään. Esimerkiksi System.out.println -komennon parametriksi voidaan antaa merkkijono hei hipsujen sisällä seuraavasti: System.out.println("hei").

Puolipiste

Puolipisteellä ; erotetaan lauseet toisistaan. Voisimme oikeastaan kirjoittaa koko ohjelman yhdelle riville -- mikä ei kuitenkaan ole kovin ymmärrettävää.

System.out.print("Hei "); System.out.print("maailma"); System.out.print("!\n");

Hei maailma!

Vaikka yllä oleva esimerkki toimii, on rivinvaihtojen käyttö tärkeää muita ohjelmoijia ajatellen. Tällöin ohjelman lukija tietää, että kullakin rivillä tehdään vain yksi konkreettinen asia.

Lohko

Lohkolla tarkoitetaan aaltosulkujen rajaamaa aluetta. Ohjelmissamme näitä on tyypillisesti useita. Ohjelman sisältävä tiedosto sisältää merkkijonon public class Ohjelma, jota seuraa lohkon avaava aaltosulku. Lohko päättyy sulkevaan aaltosulkuun. Ohjelma -- tai oikeastaan luokan (tämä termi tulee myöhemmin tutuksi) -- sisällä voi olla myös muita lohkoja.

Esimerkiksi ohjelman käynnistämiskohdan määrittelevä merkkijono public static void main(String[] args) -- tai oikeastaan metodi (tämäkin termi tulee myöhemmin tutuksi) -- määrittelee oman lohkon, jonka sisällä oleva lähdekoodi suoritetaan kun ohjelma käynnistetään.

Alla olevassa kuvassa on näytettynä Ohjelma-nimisen luokan rajaama lohko. Lohko alkaa merkkijonon public class Ohjelma jälkeen alkavasta aaltosulusta ja päättyy viimeiseen aaltosulkuun.

Yllä olevan esimerkin lohko sisältää toisen lohkon. Tämä lohko alkaa merkkijonosta public static void main(String[] args) ja sisältää ohjelman käynnistymisessä suoritettavan lähdekoodin.

Laajemmin lohkojen merkitystä voi ajatella suoritettavan ohjelman rakenteen kuvaajina. Merkkijonosta public class Ohjelma alkava lohko sisältää koko ohjelman rakenteen, kun taas merkkijonosta public static void main(String[] args) alkava lohko sisältää ohjelman käynnistyksen jälkeen suoritettavan lähdekoodin.

Lohko rajataan aina aaltosuluilla, ja aaltosuluille tulee löytyä aina pari. Tietokone ei esimerkiksi ymmärtäisi seuraavanlaista ohjelmaa, sillä siitä puuttuu yksi aaltosulku.

public class Ohjelma {

    public static void main(String[] args) {

        // Tänne voit kirjoittaa ohjelmakoodia. Ohjelmasi voit ajaa
        // valitsemalla menusta Run->Run File tai painamalla Shift+F6


}

Ohjelmointityylistä

Vaikka tietokone ja käyttämämme ohjelmointikieli ei aseta rajoituksia kirjoitettavan ohjelmakoodin ulkoasulle, olemme huomanneet että ohjelmoijan -- tai opiskelevan ohjelmoijan -- kirjoittaman koodin ulkoasulla on merkitystä myös oppimisen kannalta. Luettavuus ja sisennyksen säännönmukaisuus ovat asioita, jotka vaikuttavat lähdekoodin ymmärrettävyyteen, ja sitä kautta myös oppimistuloksiin. Seuraava koodi on säännönmukaisesti sisennettyä.

public class Esimerkki {
    public static void main(String[] args) {
        System.out.println("Heippa vaan! Tämä koodi on siististi sisennetty.");
        System.out.println("public class -- ei sisennystä.");
        System.out.println("public static -- neljän merkin sisennys.");
        System.out.println("public static ... sisällä -- kahdeksan merkin sisennys -- tai enemmän.");
    }
}

Tämä koodi taas ei ole kovin ymmärrettävää.

         public class Esimerkki {
public static void main(String[] args) {
      System.out.println("Heippa vaan! Tämä koodi on siististi sisennetty.");
 System.out.println("public class -- ei sisennystä.");
                   System.out.println("public static -- neljän merkin sisennys.");
           System.out.println("public static ... sisällä -- kahdeksan merkin sisennys -- tai enemmän.");}}

Kurssilla käytettävä Test My Code -ympäristö sisältää Checkstyle-nimisen työvälineen. Checkstyle-työvälinettä voi käyttää mm. koodin sisennyksen ja muiden tyyliseikkojen automaattiseen tarkastamiseen. Tällä kurssilla Checkstyleä käytetään tyylin tarkastamiseen.

Tyylivirheet näytetään ohjelmointiympäristössä keltaisella, ja normaalit testi-ilmoitukset punaisella. Kurssilla tutuksi tuleva tehtävän edistymispalkki muuttuu myöskin keltaiseksi, jos koodissa havaitaan tyylivirheitä. Vaikkakin näppäinyhdistelmä alt + shift + f (macOS control + shift + f) auttaa useimpien tyylivirheiden korjaamiseen, on koodia syytä kirjoittaa oikein alusta alkaen.

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

Ohjelma ja tieto

Muuttuja on keskeinen käsite ohjelmoinnissa. Muuttujia käytetään tiedon tallentamiseen myöhempää käyttöä varten. Myöhempää käyttöä on esimerkiksi tallennetun tiedon lukeminen, tulostaminen tai muuttaminen, sekä tiedon vertaileminen toiseen tietoon.

Muuttujien nimentä on ohjelmoijan vastuulla. Muuttujat nimetään tyypillisesti siten, että ne kuvaavat käyttötarkoitustaan -- esimerkiksi arvosanan sisältävän muuttujan nimeksi kannattaa asettaa arvosana.

Tiedon tyyppi

Ohjelman käsittelemä tieto on aina tietyn tyyppistä. Tyyppejä ovat esimerkiksi kokonaisluku (int), liukuluku (double) eli desimaaliluku ja totuusarvo (boolean). Kokonaisluvut ovat numeroita, esimerkiksi 42, liukuluvut desimaalilukuja, esimerkiksi 42.42 (desimaaliluvun erotusmerkki on piste), ja totuusarvot sisältävät joko arvon true, eli totta, tai arvon false, eli epätotta.

Muuttujan esittely

Muuttuja esitellään -- eli luodaan -- kertomalla ensin tiedon tyyppi, jota seuraa muuttujalle annettava nimi. Muuttujaan asetetaan arvo yhdellä yhtäsuuruusmerkillä (=).

int kuukausia = 12;

Yllä olevassa lauseessa luodaan kokonaisluku-tyyppinen muuttuja (int), jolle annetaan nimeksi kuukausia. Muuttujaan kuukausia asetetaan arvo 12. Lause luetaan "muuttuja kuukausia saa arvon 12".

Muuttujan arvo voidaan yhdistää tulostuslauseelle annettavaan parametriin +-merkillä seuraavan esimerkin mukaisesti.

public class Esimerkki {
    public static void main(String[] args) {
        int elamanTarkoitus = 123;
        double pii = 3.141592653;

        System.out.println("Elämän tarkoitus: " + elamanTarkoitus);
        System.out.println("Piin arvo on: " + pii);
    }
}

Tulostus:

Elämän tarkoitus: 123
Piin arvo on: 3.141592653

Kanoja:
3
Pekonia (kg):
5.5

Tässä vielä tiivistelmä:
3
5.5

Kanoja:
9000
Pekonia (kg):
0.1

Tässä vielä tiivistelmä:
9000
0.1

Muuttujien nimet ovat uniikkeja, eikä kahdella muuttujalla saa olla ohjelmassa samaa nimeä. Seuraavassa esimerkissä oleva ohjelma on virheellinen, koska muuttuja pii esitellään kahdesti.

public class Esimerkki {
    public static void main(String[] args) {
        double pii = 3.14;
        double pii = 3.141592653;

        System.out.println("Piin arvo on: " + pii);
    }
}

Muuttujaan asetetun arvon muuttaminen

Muuttuja on olemassa sen esittelyhetkestä lähtien, ja sen arvo säilyy kunnes muuttujaan asetetaan toinen arvo. Muuttujan arvon muuttaminen onnistuu lauseella, jossa on muuttujan nimi, yhtäsuuruusmerkki, ja muuttujan uusi arvo. Huomaa että muuttujan tyyppi kirjoitetaan vain kun muuttuja esitellään ohjelmassa ensimmäistä kertaa.

int luku = 123;
System.out.println("Muuttujan arvo on " + luku);

luku = 42;
System.out.println("Muuttujan arvo on " + luku);

Tulostus:

Muuttujan arvo on 123
Muuttujan arvo on 42

Tarkastellaan edellisen ohjelmakoodin suoritusta askel askeleelta. Kun muuttuja esitellään ohjelmakoodissa ensimmäistä kertaa, eli sekä muuttujan tyyppi (tässä int) että sen nimi (tässä luku) kerrotaan tietokoneelle, tietokone luo muuttujaa varten "nimetyn lokeron". Tämän jälkeen yhtäsuuruusmerkin oikealla puolella oleva arvo kopioidaan tähän nimettyyn lokeroon.

Kun ohjelmakoodissa viitataan muuttujaan sen nimellä -- tässä halutaan tulostaa merkkijono "Muuttujan arvo on " sekä muuttujan luku arvo, muuttujan luku arvo haetaan sen nimellä löytyvästä lokerosta.

Kun muuttujaan asetetaan arvo (tässä luku = 42), tarkistetaan ensin löytyykö muuttujan nimistä lokeroa. Jos lokero löytyy, uusi arvo kopioidaan lokeroon vanhan arvon tilalle ja vanha arvo katoaa. Jos muuttujan nimellä ei löydy lokeroa, ohjelman suoritus päättyy virheilmoitukseen tai ohjelmaa ei voida käynnistää.

Seuraavaksi ohjelmakoodissa viitataan taas muuttujaan sen nimellä -- tässäkin halutaan tulostaa merkkijono "Muuttujan arvo on " sekä muuttujan luku arvo. Toimitaan kuten normaalisti, eli haetaan muuttujan luku arvo sen nimellä löytyvästä lokerosta.

Kuten huomaat, ohjelman lopputilanteessa muuttujan alkuperäinen arvo on kadonnut. Muuttuja voi sisältää kerrallaan aina vain yhden arvon.

Muuttujan tyyppi pysyy

Kun muuttujan tyyppi on kertaalleen määritelty, ei sitä voi enää muuttaa. Totuusarvoa ei siis voi esimerkiksi asettaa kokonaislukutyyppiseen muuttujaan, eikä totuusarvomuuttujaan voi asettaa kokonaislukua.

boolean onnistuukoKokonaisLuvunAsetus = false;
onnistuukoKokonaisLuvunAsetus = 42; // Ei onnistu

int luku = 10;
onnistuukoKokonaisLuvunAsetus = luku; // Ei myöskään onnistu

Poikkeus kuitenkin löytyy: liukulukutyyppiseen muuttujaan voi asettaa kokonaisluvun, sillä Java osaa muuttaa kokonaisluvun liukuluvuksi asetuksen yhteydessä.

double liukuluku = 0.42;
liukuluku = 1; // Onnistuu

int luku = 10;
liukuluku = luku; // Onnistuu myös

Liukulukua ei kuitenkaan voi asettaa kokonaislukuun. Tämä johtuu siitä, että ohjelmointikielen suunnittelijat yrittävät suojella ohjelmoijaa tietoa kadottavilta ohjelmointivirheiltä.

int luku = 4.2; // Ei onnistu

double liukuluku = 0.42;
luku = liukuluku; // Ei myöskään onnistu

Muuttujan nimentä

Muuttujien nimentä on oleellinen osa ohjelman kuvausta. Tarkastellaan kahta esimerkkiä.

double a = 3.14;
double b = 22.0;
double c = a * b * b;

System.out.println(c);

1519.76

double pii = 3.14;
double sade = 22.0;
double pintaAla = pii * sade * sade;

System.out.println(pintaAla);

1519.76

Edellä olevat kaksi esimerkkiä sisältävät täsmälleen saman toiminnallisuuden ja tuottavat saman tulostuksen. Toinen esimerkeistä on kuitenkin paljon ymmärrettävämpi. Kyseessä on ympyrän pinta-alan laskevan ohjelman koodi. Ensimmäisellä rivillä määritellään piin arvo, toisella rivillä ympyrän säde, ja kolmannella rivillä lasketaan pinta-ala. Tämän jälkeen pinta-ala tulostetaan.

Muuttujan nimeämistä rajoittavat tietyt ehdot.

Muuttujan nimessä ei saa olla tiettyjä erikoismerkkejä, kuten huutomerkkejä (!). Välilyönti ei ole sallittu, sillä se erottaa komentojen osat toisistaan. Välilyönti kannattaa korvata camelCase<-tyylillä, jolloin nimi muistuttaneeKamelia. Huom! Muuttujien nimien ensimmäinen kirjain kirjoitetaan aina pienellä:

int camelCaseMuuttuja = 7;

Numeroita voidaan käyttää muuttujan nimessä, kunhan nimi ei ala numerolla. Nimi ei myöskään voi koostua pelkistä numeroista.

int 7muuttuja = 4; // Ei sallittu!
int muuttuja7 = 4; // Sallittu, mutta ei kuvaava muuttujan nimi

Muuttujan nimi ei saa olla jo entuudestaan käytössä. Tällaisia nimiä ovat mm. aikaisemmin määritellyt muuttujat ja Javan valmiit komennot, kuten System.out.print ja System.out.println.

int camelCase = 2;
int camelCase = 5; // Ei sallittu -- muuttuja camelCase on jo käytössä!

Muuttujien nimissä ei tule myöskään käyttää ääkkösiä. Voit korvata ääkköset aakkosilla, eli muuta ä -> a ja ö -> o.

Sallittuja muuttujien nimiä

• kuukaudenViimeinenPaiva = 20
• ensimmainenVuosi = 1952
• nimi = "Essi"

Virheellisiä muuttujien nimiä

• kuukauden viimeinen päivä = 20
• 1paiva = 1952
• varo! = 1910
• 1920 = 1

Tietokone on laskin

Tietokone on käytännössä erittäin tehokas laskin. Tietokoneen suoritin hakee suoritettavaan ohjelmaan liittyvät konekieliset käskyt muistista ja suorittaa niitä yksi kerrallaan. Tietokoneen käyttöjärjestelmän -- joka sekin on ohjelma -- vastuulla on suoritettavan ohjelman valinta.

Tutustutaan seuraavaksi tyypillisimpiin laskuoperaatioihin.

Laskentaa

Laskuoperaatiot ovat tuttuja ja suoraviivaisia: yhteenlasku +, erotus -, kertolasku * ja jakolasku /. Laskentajärjestys on myös tuttu: laskenta tehdään vasemmalta oikealle sulut huomioon ottaen. Kuitenkin * ja / lasketaan ennen + ja - operaatioita, samoin kuin perus- tai kansakoulumatematiikassa on tullut tutuksi.

int eka = 2;
System.out.println(eka); // tulostaa 2
int toka = 4;
System.out.println(toka); // tulostaa 4

int summa = eka + toka; // muuttujaan summa asetetaan muuttujien eka ja toka arvojen summa
System.out.println(summa); // tulostaa 6

Laskujärjestys ja sulut

Laskujärjestykseen voi vaikuttaa sulkujen avulla. Sulkujen sisällä olevat laskuoperaatiot suoritetaan ennen niiden ulkopuolella olevia laskuoperaatioita.

int laskuSuluilla = (1 + 1) + 3 * (2 + 5);
System.out.println(laskuSuluilla); // tulostaa 23

int laskuSuluitta = 1 + 1 + 3 * 2 + 5;
System.out.println(laskuSuluitta); // tulostaa 13

Yllä olevan esimerkin voi jakaa myös osiin.

int laskuSuluilla = (1 + 1);
System.out.println(laskuSuluilla); // tulostaa 2
laskuSuluilla = laskuSuluilla + 3 * (2 + 5);
System.out.println(laskuSuluilla); // tulostaa 23

int laskuSuluitta = 1 + 1;
laskuSuluitta = laskuSuluitta + 3 * 2;
laskuSuluitta = laskuSuluitta + 5;
System.out.println(laskuSuluitta); // tulostaa 13

Vuodessa on X sekuntia.

int laskuSuluitta = 1 + 1 + 3 * 2 + 5;

Lausekkeen evaluointi tapahtuu ohjelmakoodissa siinä kohtaa, missä lauseke on. Evaluointi onnistuu siis esimerkiksi myös tulostuslauseen yhteydessä, jos lauseketta käytetään tulostuslauseen parametrin arvon laskemisessa.

int eka = 2;
int toka = 4;

System.out.println(eka + toka); // tulostaa 6
System.out.println(2 + toka - eka - toka); // tulostaa 0

Lauseke ei muuta muuttujassa olevaa arvoa, ellei lausekkeen lopputulosta aseteta muuttujan arvoksi tai anneta parametrina esimerkiksi tulostukselle.

int eka = 2;
int toka = 4;

// alla oleva lauseke ei edes toimi, sillä lauseketta
// ei aseteta minkään muuttujan arvoksi tai anneta parametrina
// tulostuslauseelle
eka + toka;

Laskentaa ja tulostamista

Muuttujan arvon voi tulostaa komennolla System.out.println. Tulostettavaan hipsuilla merkittyyn merkkijonoon, esim. "Pituus ", voidaan lisätä muuta tulostettavaa operaation + avulla.

int pituus = 42;
System.out.println("Pituus " + pituus);

Pituus 42

System.out.println("tuossa on kokonaisluku --> " + 2);
System.out.println(2 + " <-- tuossa on kokonaisluku");

tuossa on kokonaisluku --> 2
2 <-- tuossa on kokonaisluku

Jos toinen operaation + kohteista on merkkijono, muutetaan myös toinen operaation kohteista merkkijonoksi ohjelman suorituksen yhteydessä. Alla olevassa esimerkissä kokonaisluku 2 on muutettu merkkijonoksi "2", ja siihen on yhdistetty merkkijono.

Aiemmin esitellyt laskusäännöt pätevät täälläkin:

System.out.println("Neljä: " + (2 + 2));
System.out.println("Mutta! kaksikymmentäkaksi: " + 2 + 2);

Neljä: 4
Mutta! kaksikymmentäkaksi: 22

Edellistä tietoa soveltamalla voimme luoda lausekkeen, joka sisältää tekstiä ja muuttujan, ja joka evaluoidaan tulostuksen yhteydessä:

int x = 10;

System.out.println("muuttujan x arvo on: " + x);

int y = 5;
int z = 6;

System.out.println("y on " + y + " ja z on " + z);

Tulostus:

muuttujan x arvo on: 10
y on 5 ja z on 6

// 1. määritellään syötteet ja luodaan niitä varten muuttujat
int eka = 1;
int toka = 2;

// 2. selvitetään laskuoperaatio ja luodaan laskuoperaation tulokselle muuttuja
int summa = eka + toka;

// 3. tulostetaan laskuoperaation tulos
System.out.println("Lukujen " + eka + " ja " + toka + " summa on " + summa);  

5 + 4 = 9

73457 + 12888 = 86345

2 * 8 = 16

277 * 111 = 30747

Jakolasku

Kokonaislukujen jakolasku on hieman hankalampi operaatio. Jakolausekkeessa käytettyjen muuttujien tyyppi määrää evaluaation tuloksena saatavan arvon tyypin. Jos kaikki jakolausekkeessa olevat muuttujat ovat kokonaislukuja, on tulos myös kokonaisluku.

int tulos = 3 / 2;
System.out.println(tulos); // Huom! tulostaa 1 (kokonaisluku), sillä 3 ja 2 ovat myös kokonaislukuja

int eka = 3:
int toka = 2;
double tulos = eka / toka;
System.out.println(tulos); // nytkin tulostus on 1, sillä eka ja toka ovat kokonaislukuja

Jos jakolaskun jakaja tai jaettava (tai molemmat!) ovat liukulukuja, tulee tulokseksi myös liukuluku.

double kunJaettavaOnLiukuluku = 3.0 / 2;
System.out.println(kunJaettavaOnLiukuluku); // tulostaa 1.5

double kunJakajaOnLiukuluku = 3 / 2.0;
System.out.println(kunJakajaOnLiukuluku); // tulostaa 1.5

Kokonaisluku voidaan tarvittaessa muuttaa liukuluvuksi lisäämällä sen eteen tyyppimuunnosoperaatio (double):

int eka = 3;
int toka = 2;

double tulos1 = (double) eka / toka;
System.out.println(tulos1); // tulostaa 1.5

double tulos2 = eka / (double) toka;
System.out.println(tulos2); // tulostaa 1.5

double tulos3 = (double) (eka / toka);
System.out.println(tulos3); // tulostaa 1.0

Jälkimmäisessä esimerkissä tulos pyöristyy väärin sillä laskuoperaatio kokonaisluvuilla suoritetaan ennen tyyppimuunnosta.

Jos jakolausekkeen tulos asetetaan kokonaislukutyyppiseen muuttujaan, on tulos automaattisesti kokonaisluku.

// tulos automaattisesti kokonaisluku: 1
int tulosKokonaislukuKoskaTyyppiKokonaisluku = 3.0 / 2;

Seuraava esimerkki tulostaa "1.5", sillä jaettavasta tehdään liukuluku kertomalla se liukuluvulla (1.0 * 3 = 3.0) ennen jakolaskua.

int jaettava = 3;
int jakaja = 2;

double tulos = 1.0 * jaettava / jakaja;
System.out.println(tulos);

eka: 9
toka: 7
kolmas: 6

eka: 9
toka: 7
kolmas: 6
keskiarvo: 7.333333333333333

eka: 5
toka: 7
kolmas: 4
keskiarvo: 5.333333333333333

5 + 3 = 8

5 + 3 = 8
5 - 3 = 2
5 * 3 = 15
5 / 3 = 1.6666666666666667

1 + 3 = 4
1 - 3 = -2
1 * 3 = 3
1 / 3 = 0.3333333333333333

Muuttujan arvoon liittyviä väärinkäsityksiä

Kun tietokone suorittaa ohjelmakoodia, suorittaa se sitä käsky kerrallaan, edeten aina täsmälleen siten, kuin ohjelmakoodissa sanotaan. Kun muuttujaan asetetaan arvo, tapahtuu aina sama asia, eli yhtäsuuruusmerkin oikealla puolella oleva arvo kopioidaan yhtäsuuruusmerkin vasemmalla puolella olevan muuttujan arvoksi, eli muuttujan nimeämään paikkaan.

On tärkeää, että ohjelmoija ymmärtää, että arvon asettaminen muuttujaan tekee aina saman asian.

Kolme yleistä väärinkäsitystä, jotka liittyvät muuttujan arvon asettamiseen ovat seuraavat:

• Muuttujan asettamisen näkeminen siirtona kopioimisen sijaan: ohjelmakoodin eka = toka suorituksen jälkeen ajatellaan, että muuttujan toka arvo on siirtynyt muuttujan eka arvoksi, jonka jälkeen muuttujalla toka ei ole enää arvoa, tai sen arvo on esimerkiksi nolla. Tämä ei pidä paikkansa, sillä ohjelmakoodin eka = toka suorituksessa muuttujan toka nimeämässä paikassa oleva arvo kopioidaan muuttujan eka nimeämään paikkaan. Muuttujan toka arvo ei siis muutu.
  
• Muuttujan asettamisen näkeminen riippuvuutena kopioimisen sijaan: ohjelmakoodin eka = toka suorituksen jälkeen ajatellaan, että mikä tahansa muutos muuttujaan toka vaikuttaa automaattisesti myös muuttujaan eka. Tämä ei pidä paikkansa, sillä asetus -- kopiointi -- on yksittäinen tapahtuma. Se tapahtuu vain silloin, ohjelmakoodi eka = toka suoritetaan.
  
• Kolmas väärinkäsitys liittyy kopioimisen suuntaan: ohjelmakoodin eka = toka suorituksessa ajatellaan, että muuttujan toka arvoksi kopioidaan muuttujan eka arvo. Tämä näkyy myös tilanteina, missä ohjelmoija voi vahingossa kirjoittaa esimerkiksi 42 = arvo -- onneksi ohjelmointiympäristöt tukevat myös tässä.

Ehkäpä paras tapa tietokoneen ohjelmakoodin suorittamisen ymmärtämiseen on paperin ja kynän käyttäminen. Kun luet ohjelmakoodia, kirjoita paperille uusien muuttujien nimet, sekä kirjoita ylös rivi riviltä, miten ohjelmakoodissa olevien muuttujien arvot muuttuvat. Havainnollistetaan suoritusta seuraavalla ohjelmakoodilla:

rivi 1: int eka = (1 + 1);
rivi 2: int toka = eka + 3 * (2 + 5);
rivi 3:
rivi 4: eka = 5;
rivi 5:
rivi 6: int kolmas = eka + toka;
rivi 7: System.out.println(eka);
rivi 8: System.out.println(toka);
rivi 9: System.out.println(kolmas);

Alla on kirjoitettu yllä olevan ohjelmakoodin suoritus auki.

rivi 1: luodaan muuttuja eka
rivi 1: kopioidaan muuttujan eka arvoksi laskun 1 + 1 tulos
rivi 1: muuttujan eka arvo on 2

rivi 2: luodaan muuttuja toka
rivi 2: lasketaan 2 + 5, 2 + 5 ->  7
rivi 2: lasketaan 3 * 7, 3 * 7 -> 21
rivi 2: lasketaan eka + 21
rivi 2: kopioidaan muuttujan eka arvo laskuun, muuttujan eka arvo on 2
rivi 2: lasketaan 2 + 21, 2 + 21 -> 23
rivi 2: kopioidaan muuttujan toka arvoksi 23
rivi 2: muuttujan toka arvo on 23

rivi 3: (tyhjä, ei tehdä mitään)

rivi 4: kopioidaan muuttujan eka arvoksi 5
rivi 4: muuttujan eka arvo on 5

rivi 5: (tyhjä, ei tehdä mitään)

rivi 6: luodaan muuttuja kolmas
rivi 6: lasketaan eka + toka
rivi 6: kopioidaan muuttujan eka arvo laskuun, muuttujan eka arvo on 5
rivi 6: lasketaan 5 + toka
rivi 6: kopioidaan muuttujan toka arvo laskuun, muuttujan toka arvo on 23
rivi 6: lasketaan 5 + 23 -> 28
rivi 6: kopioidaan muuttujan kolmas arvoksi 28
rivi 6: muuttujan kolmas arvo on 28

rivo 7: tulostetaan muuttuja eka
rivi 7: kopioidaan muuttujan eka arvo tulostettavaksi, muuttujan eka arvo on 5
rivi 7: tulostetaan arvo 5

rivi 8: tulostetaan muuttuja toka
rivi 8: kopioidaan muuttujan toka arvo tulostettavaksi, muuttujan toka arvo on 23
rivi 8: tulostetaan arvo 23

rivi 9: tulostetaan muuttuja kolmas
rivi 9: kopioidaan muuttujan kolmas arvo tulostettavaksi, muuttujan kolmas arvo on 28
rivi 9: tulostetaan arvo 28

Alla edellinen ohjelma askeleittain visualisoituna. Käytössä oleva askeleittainen visualisointi käsittelee ohjelmakoodia riveittäin -- pohdi askeleiden kohdalla miten ohjelma päätyy sen tulostamaan lopputulokseen.

Jakolaskin

Tässä tehtävässä harjoittelet ensimmäistä kertaa tuntemattoman ohjelman muokkaamista. Vaikka suurin osa ohjelmasta tuntuu kryptiseltä, etkä tunne lähdekoodissa käytettyjä sanoja lainkaan, huomaat sieltä todennäköisesti myös tuttuja asioita.

Tehtäväpohjaan on toteutettuna graafinen (eli ohjelma avautuu ikkunassa) jakolaskin. Ohjelmassa on kuitenkin pientä häikkää, kuten alla olevasta esimerkistä huomaat.

Etsi vika ja korjaa se. Huomaa, että tässä tehtävässä (ja muissa käyttöliittymiin liittyvissä tehtävissä) automaattiset testit käyttävät hiirtäsi. Älä siis käytä hiirtäsi testien ajon aikana.

Huom! Isolla resoluutiolla varustelluissa koneissa on huomattu ongelmia hiirtä liikuttavan testikirjaston kanssa. Jos huomaat, että ohjelmasi toimii kun käynnistät sen itse ja kokeilet sen toimintaa, mutta testien ajaminen epäonnistuu, lähetä tehtävä palvelimelle arvioitavaksi.

Käyttäjän syötteen lukeminen

Edellisissä ohjelmissamme tietokonetta on käytetty lähes poikkeuksetta hyvin yksinkertaisena laskimena. Laskuoperaatioiden käsittelemät luvut on syötetty lähdekoodiin, eikä käyttäjä ole päässyt syöttämään niitä itse.

Tutustutaan seuraavaksi syötteen lukemiseen käyttäjältä. Syötteen lukemiseen käytetään Javan valmista Scanner-apuvälinettä. Apuväline tuodaan käyttöön lisäämällä komento import java.util.Scanner; ennen pääohjelmarungon aloitusta (public class ...).

import java.util.Scanner; // tuodaan lukemiseen käytetty apuväline Scanner käyttöömme

public class Esimerkki {

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

        // ohjelmakoodi
    }
}

Älä hätäile vaikka pääohjelmarunko saattaa näyttää vaikeaselkoiselta! Jatkamme yhä ohjelmointia kommentilla ohjelmakoodi merkittyyn kohtaan.

Kokonaisluvun lukeminen

Kokonaislukujen lukeminen tapahtuu lukemalla käyttäjältä syöterivi (komento lukija.nextLine()), joka annetaan komennolle Integer.parseInt. Komento Integer.parseInt muuntaa sille annetun syöterivin kokonaislukumuuttujaksi, olettaen että tämä on mahdollista.

System.out.print("Anna kokonaisluku: ");
int kokonaisluku = Integer.parseInt(lukija.nextLine());

System.out.println("Annoit " + kokonaisluku);

Jatkossa esimerkkitulostuksissa merkitään punaisella käyttäjän syöttämät arvot. Edeltävän ohjelman suoritus olisi seuraavanlainen, olettaen, että käyttäjä syöttää arvon 25.

Anna kokonaisluku: 25

Annoit 25

Anna luku: 42

Syötit: 42

Useamman luvun lukeminen onnistuu myös luontevasti. Alla olevassa esimerkissä ohjelma kysyy käyttäjältä kolme lukua ja tulostaa niiden keskiarvon.

System.out.println("Ohjelma kysyy kolme kokonaislukua ja tulostaa niiden keskiarvon.");
System.out.print("Anna kokonaisluku: ");
int eka = Integer.parseInt(lukija.nextLine());
System.out.print("Anna kokonaisluku: ");
int toka = Integer.parseInt(lukija.nextLine());
System.out.print("Anna kokonaisluku: ");
int kolmas = Integer.parseInt(lukija.nextLine());

double keskiarvo = (eka + toka + kolmas) / 3.0;

System.out.println("Syötettyjen lukujen keskiarvo " + keskiarvo);

Ohjelma kysyy kolme kokonaislukua ja tulostaa niiden keskiarvon.
Anna kokonaisluku:
1
Anna kokonaisluku:
3
Anna kokonaisluku:
5
Syötettyjen lukujen keskiarvo 3.0

Jokaista muuttujaa ei tarvitse aina kirjoittaa auki erikseen. Esimerkiksi edellisen ohjelman voi toteuttaa myös niin, että ohjelmassa käytetään vain yhtä muuttujaa, jonka tehtävänä on syötettyjen lukujen summan ylläpito.

System.out.println("Ohjelma kysyy kolme kokonaislukua ja tulostaa niiden keskiarvon.");
System.out.print("Anna kokonaisluku: ");
int summa = Integer.parseInt(lukija.nextLine());
System.out.print("Anna kokonaisluku: ");
summa = summa + Integer.parseInt(lukija.nextLine());
System.out.print("Anna kokonaisluku: ");
summa = summa + Integer.parseInt(lukija.nextLine());

System.out.println("Syötettyjen lukujen keskiarvo " + (1.0 * summa / 3));

Anna ensimmäinen luku: 6
Anna toinen luku: 2

Lukujen summa: 8

Anna ensimmäinen luku: 5
Anna toinen luku: 2
Anna kolmas luku: 12

Lukujen summa: 19

Anna ensimmäinen luku: 3
Anna toinen luku: 2

Jakolasku: 3 / 2 = 1.5

Anna ympyrän säde: 20

Ympyrän kehä: 125.66370614359172

Päätösten tekeminen

Ohjelmamme ovat toistaiseksi edenneet suoraviivaisesti lauseesta seuraavaan, toimien jokaisella suorituskerralla samalla tavalla. Haluamme mahdollisuuden erilaisille ohjelman suorituspoluille.

Ehtolause

Jotta ohjelman suoritus voisi haarautua esimerkiksi käyttäjän antaman syötteen perusteella, tarvitsemme käyttöömme ehtolauseen.

Ehtolause alkaa avainsanalla if, jota seuraa sulut. Sulkujen sisälle asetetaan lauseke, joka evaluoidaan kun ehtolause saavutetaan. Sulkuja seuraa lohko, joka määritellään avaavan aaltosulun { ja sulkevan aaltosulun } sisään. Lohko suoritetaan jos sulkujen sisälle asetettu lauseke evaluoidaan todeksi.

int luku = 11;

if (luku > 10) {
    System.out.println("Luku oli suurempi kuin 10");
}

Jos ehtolauseen lauseke evaluoidaan todeksi, yllä "jos muuttujassa luku oleva arvo on suurempi kuin 10", ohjelman suoritus siirtyy ehtolauseen määrittelemään lohkoon. Jos taas lauseke on epätotta, ohjelman suoritus siirtyy ehtolauseeseen liittyvän lohkon päättävän aaltosulun jälkeiseen lauseeseen.

Huomaa, että if -lauseen perään ei tule puolipistettä, sillä lause ei lopu ehto-osan jälkeen.

if (luku > 10) {
luku = 9;
}

if (luku > 10) {
    luku = 9;
}

Kerro nopeus: 15

Kerro nopeus: 135

Ylinopeussakko!

Vertailuoperaattorit

Vertailuoperaattoreita ovat seuraavat:

• >suurempi kuin
• >=suurempi tai yhtä suuri kuin
• <pienempi kuin
• <= pienempi tai yhtä suuri kuin
• == yhtä suuri kuin
• != erisuuri kuin

int luku = 55;

if (luku != 0) {
    System.out.println("Luku oli erisuuri kuin 0");
}

if (luku >= 1000) {
    System.out.println("Luku oli vähintään 1000");
}

Luku oli erisuuri kuin 0

Anna luku: 1983

Anna luku: 1984

Orwell

Anna vuosiluku: 2017

Anna vuosiluku: 2013

Wanha!

Muulloin eli else

Jos ehtolauseen sulkujen sisällä oleva lauseke evaluoituu epätodeksi, ohjelmakoodin suoritus siirtyy ehtolauseen lohkon lopettavan aaltosulun seuraavaan lauseeseen. Tämä ei aina ole toivottua, vaan usein halutaan luoda vaihtoehtoinen toiminta tilanteeseen, missä ehtolauseen lauseke on epätotta.

Tämä onnistuu if-komennon yhteydessä käytettävän else-komennon avulla.

int luku = 4;

if (luku > 5) {
    System.out.println("Lukusi on suurempi kuin viisi!");
} else {
    System.out.println("Lukusi on viisi tai alle!");
}

Lukusi on viisi tai alle!

Jos ehtolauseeseen on määritelty else-haara, suoritetaan else-haaran määrittelemä lohko jos ehtolauseen ehto ei ole totta. Komento else tulee samalle riville if-komennon määrittelemän lohkon lopettavan aaltosulun kanssa.

Huom! Jos et sisennä em. tavalla, tyylitarkastaja valittaa "Line xx: '}' should be on the same line."

Anna luku: 5

Luku on positiivinen.

Anna luku: -2

Luku ei ole positiivinen.

Kuinka vanha olet? 12

Et ole täysi-ikäinen!

Kuinka vanha olet? 32

Olet täysi-ikäinen!

Lisää vaihtoehtoja: else if

Jos vaihtoehtoja on useampia käytetään else if-komentoa. Komento else if on kuin else, mutta lisäehdolla. else if tulee if-ehdon jälkeen, ja niitä voi olla useita.

int luku = 3;

if (luku == 1) {
    System.out.println("Luku on yksi");
} else if (luku == 2) {
    System.out.println("Lukuna on kaksi");
} else if (luku == 3) {
    System.out.println("Kolme lienee lukuna!");
} else {
    System.out.println("Jotain muuta!");
}

Kolme lienee lukuna!

Luetaan yllä oleva esimerkki: 'Jos luku on yksi, tulosta "Luku on yksi", muuten jos luku on kaksi, tulosta "Lukuna on kaksi", muuten jos lukuna on kolme, tulosta "Kolme lienee lukuna!". Muulloin, tulosta "Jotain muuta!"'.

Yllä olevan ohjelman askeleittainen visualisointi:

Anna ensimmäinen luku: 5
Anna toinen luku: 3

Suurempi luku: 5

Anna ensimmäinen luku: 5
Anna toinen luku: 8

Suurempi luku: 8

Anna ensimmäinen luku: 5
Anna toinen luku: 5

Luvut ovat yhtä suuret!

Vertailujen suoritusjärjestys

Vertailut suoritetaan järjestyksessä ylhäältä alaspäin. Kun suorituksessa päästään ehtolauseeseen, jonka ehto on totta, suoritetaan lohko ja lopetetaan vertailu.

int luku = 5;

if (luku == 0) {
    System.out.println("Luku on nolla.");
} else if (luku > 0) {
    System.out.println("Luku on suurempi kuin nolla.");
} else if (luku > 2) {
    System.out.println("Luku on suurempi kuin kaksi.");
} else {
    System.out.println("Luku on pienempi kuin nolla.");
}

Luku on suurempi kuin nolla.

Yllä oleva esimerkki tulostaa merkkijonon "Luku on suurempi kuin nolla." vaikka myös ehto luku > 2 on totta. Vertailu lopetetaan ensimmäiseen valintakäskyyn, jonka ehto on totta.

Anna pisteet [0-100]: 37

Arvosana: hylätty

Anna pisteet [0-100]: 76

Arvosana: 2

Anna pisteet [0-100]: 95

Arvosana: 5

Anna pisteet [0-100]: -3

Arvosana: mahdotonta!

Määrä

Tehtävän graafiseen käyttöliittymään on lisätty liukuri sekä tekstikenttä.

Tutustu ohjelman koodiin ja muokkaa ohjelmaa siten, että tekstikentän arvo muuttuu liukurista saatavien arvojen perusteella seuraavasti:

• Jos liukurin arvo on 0, tekstin tulee olla "Ei lainkaan."
• Jos liukurin arvo on 1-25, tekstin tulee olla "Vähän."
• Jos liukurin arvo on 26-74, tekstin tulee olla "Kohtalaisesti."
• Jos liukurin arvo on 75-99, tekstin tulee olla "Paljon."
• Jos liukurin arvo on 100, tekstin tulee olla "Kaikki."

Huomaa, ettei ohjelmakoodista tarvitse ymmärtää kokonaisuudessaan -- opimme luomaan graafisia käyttöliittymiä Ohjelmoinnin jatkokurssilla.

Ehtolauseen lauseke ja totuusarvomuuttuja

Ehtolauseen sulkuihin asetettavan arvon tulee olla lausekkeen evaluoinnin jälkeen totuusarvotyyppinen. Totuusarvomuuttujan tyyppi on boolean ja arvo true tai false.

boolean onkoTotta = true;
System.out.println("Totuusarvomuuttujan arvo on " + onkoTotta);

Totuusarvomuuttujan arvo on true

Ehtolauseen voi suorittaa myös seuraavasti:

boolean onkoTotta = true;

if (onkoTotta) {
    System.out.println("Aika vinhaa!");
}

Aika vinhaa!

Vertailuoperaattoreita voi käyttää myös ehtojen ulkopuolella. Tällöin vertailun tuloksena saatu totuusarvo asetetaan talteen totuusarvomuuttujaan myöhempää käyttöä varten.

int eka = 1;
int toka = 3;

boolean onkoSuurempi = eka > toka;

Yllä olevassa esimerkissä totuusarvomuuttuja onkoSuurempi sisältää nyt totuusarvon false. Yllä olevaa esimerkkiä voi myös jatkaa ja ottaa siihen mukaan ehtolauseen.

int eka = 1;
int toka = 3;

boolean onkoPienempi = eka < toka;

if (onkoPienempi) {
    System.out.println("1 on pienempi kuin 3!");
}

Yllä olevassa kuvassa ohjelmakoodia on suoritettu niin pitkään, että ohjelman muuttujat on luotu ja niihin on asetettu arvot. Muuttujassa onkoPienempi on arvona true. Seuraavana suoritetaan vertailu if (onkoPienempi) -- muuttujaan onkoPienempi liittyvä arvo löytyy sen lokerosta, ja lopulta ohjelma tulostaa:

1 on pienempi kuin 3!

int jakojaannos = 7 % 2;
System.out.println(jakojaannos); // tulostaa 1

System.out.println(5 % 3); // tulostaa 2
System.out.println(7 % 4); // tulostaa 3
System.out.println(8 % 4); // tulostaa 0
System.out.println(1 % 2); // tulostaa 1

Scanner lukija = new Scanner(System.in);
int luku = Integer.parseInt(lukija.nextLine());
int jakojaannos = luku % 400;

if (jakojaannos == 0) {
    System.out.println("Luku " + luku + " on jaollinen neljälläsadalla.");
} else {
    System.out.println("Luku " + luku + " ei ole jaollinen neljälläsadalla.");
}

Scanner lukija = new Scanner(System.in);
int luku = Integer.parseInt(lukija.nextLine());

if (luku % 400 == 0) {
    System.out.println("Luku " + luku + " on jaollinen neljälläsadalla.");
} else {
    System.out.println("Luku " + luku + " ei ole jaollinen neljälläsadalla.");
}

Anna luku: 2
Luku 2 on parillinen.

Anna luku: 7
Luku 7 on pariton.

Montako osallistujaa? 5
Montako pitsaa? 2
Montako palaa per pitsa? 6

Paloja jää yli: 2

Montako osallistujaa? 14
Montako pitsaa? 2
Montako palaa per pitsa? 6

Paloja jää yli: 12

Loogiset operaatiot

Materiaalin esimerkeissä ja tehtävissä käytetyt ehtolauseet ovat tähän mennessä käyttäneet yksinkertaisia lausekkeita, joilla on tarkasteltu ehtolauseeseen ja toistolauseeseen liittyvän lähdekoodin suorittamista. Esim.

if (lauseke) {
    System.out.println("Suoritetaan jos lausekkeen arvo on true");
}

int luku = 2;

if (luku % 2 == 0) {
    System.out.println("Luku on parillinen");
}

Luku on parillinen

Ehtolauseen lauseke voi koostua myös useammasta osasta, joissa käytetään loogisia operaatioita ja && ja tai ||. Kaksi ehtoa sisältävä lauseke, jossa on ja-operaatio on totta jos ja vain jos kummatkin ehdoista ovat tosia. Toisaalta, kaksi ehtoa sisältävä lauseke, jossa on tai-operaatio on totta jos jompikumpi tai molemmat ehdoista ovat tosia.

Seuraavassa yhdistetään &&:lla eli ja-operaatiolla kaksi yksittäistä ehtoa. Koodilla tarkistetaan, onko muuttujassa oleva luku suurempi kuin 4 ja pienempi kuin 11, eli siis välillä 5-10:

System.out.println("Onkohan luku väliltä 5-10: ");
int luku = 7;

if (luku > 4 && luku < 11) {
    System.out.println("On! :)");
} else {
    System.out.println("Ei ollut :(")
}

Onkohan luku väliltä 5-10:
On! :)

Seuraavassa annetaan ||:n eli tai-operaation avulla kaksi vaihtoehtoa, onko luku pienempi kuin 0 tai suurempi kuin 100. Ehto toteutuu jos luku täyttää jommankumman ehdon:

System.out.println("Onkohan luku pienempi kuin 0 tai suurempi kuin 100");
int luku = 145;

if (luku < 0 || luku > 100) {
    System.out.println("On! :)");
} else {
    System.out.println("Ei ollut :(")
}

Onkohan luku pienempi kuin 0 tai suurempi kuin 100
On! :)

• Looginen operaatio ja: lauseke1 && lauseke2 lausekkeen arvo on tosi kun molemmat ehdoista ovat tosia
• Looginen operaatio tai: lauseke1 || lauseke2 lausekkeen arvo on tosi jos jompikumpi tai molemmat ehdoista tosia

Kuinka vanha olet? 10
OK

Kuinka vanha olet? 55
OK

Kuinka vanha olet? -3
Mahdotonta!

Kuinka vanha olet? 150
Mahdotonta!

Ongelman ratkaiseminen osa kerrallaan

Tutustutaan klassiseen ohjelmointiongelmaan:

'Kirjoita ohjelma, joka kysyy käyttäjältä lukua yhden ja sadan väliltä ja tulostaa luvun. Jos luku on kolmella jaollinen, luvun sijaan tulostetaan "Fizz". Jos luku on viidellä jaollinen, luvun sijaan tulostetaan "Buzz". Jos luku on sekä kolmella että viidellä jaollinen, luvun sijaan tulostetaan "FizzBuzz"'.

Ohjelmoija lähtee ratkaisemaan tehtävää lukemalla ongelmakuvauksen, ja luomalla ohjelmakoodia ongelmakuvausta seuraten. Koska ohjelman suoritusehdot esitellään ongelmassa annetussa järjestyksessä, muodostuu ohjelman rakenne järjestyksen perusteella. Ohjelman rakenne muodostuu seuraavien askelten perusteella:

1. Tee ohjelma, joka lukee luvun käyttäjältä ja tulostaa sen.
2. Jos luku on jaollinen kolmella, tulosta luvun sijaan merkkijono "Fizz".
3. Jos luku on jaollinen viidellä, tulosta luvun sijaan merkkijono "Buzz".
4. Jos luku on jaollinen kolmella ja viidellä, tulosta luvun sijan merkkijono "FizzBuzz".

Jos-tyyppiset ehdot on helppo toteuttaa if - else if - else -valintakäskyjen avulla. Alla oleva koodi on toteutettu yllä olevien askelten perusteella, mutta se ei kuitenkaan toimi oikein. Kokeile!

Scanner lukija = new Scanner(System.in);

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

if (luku % 3 == 0) {
    System.out.println("Fizz");
} else if (luku % 5 == 0) {
    System.out.println("Buzz");
} else if (luku % 3 == 0 && luku % 5 == 0) {
    System.out.println("FizzBuzz");
} else {
    System.out.println(luku);
}

Valintakäskyjen suoritusjärjestyksestä

Edellisessä lähestymistavassa ongelmana on se, että valintakäskyjen läpikäynti lopetetaan ensimmäiseen ehtoon, jonka arvo on totta. Esimerkiksi luvulla 15 tulostetaan merkkijono "Fizz", sillä luku on kolmella jaollinen (15 % 3 == 0).

Yksi lähestymistapa yllä olevan ajatusketjun kehittämiseen on ensin etsiä vaativin ehto ja toteuttaa se. Tämän jälkeen toteutettaisiin muut ehdot. Yllä olevassa esimerkissä ehto "jos luku on jaollinen kolmella ja viidellä" vaatii kahden tapauksen toteutumista. Nyt ajatusketju olisi muotoa.

1. Tee ohjelma, joka lukee luvun käyttäjältä ja tulostaa sen.
2. Jos luku on jaollinen kolmella ja viidellä, tulosta luvun sijan merkkijono "FizzBuzz".
3. Jos luku on jaollinen kolmella, tulosta luvun sijaan merkkijono "Fizz".
4. Jos luku on jaollinen viidellä, tulosta luvun sijaan merkkijono "Buzz".

Nyt ongelmakin tuntuu ratkeavan.

Scanner lukija = new Scanner(System.in);

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

if (luku % 3 == 0 && luku % 5 == 0) {
    System.out.println("FizzBuzz");
} else if (luku % 3 == 0) {
    System.out.println("Fizz");
} else if (luku % 5 == 0) {
    System.out.println("Buzz");
} else {
    System.out.println(luku);
}

2
2

5
Buzz

30
FizzBuzz

Anna vuosi: 2011
Vuosi ei ole karkausvuosi.

Anna vuosi: 2012
Vuosi on karkausvuosi.

Anna vuosi: 1800
Vuosi ei ole karkausvuosi.

Anna vuosi: 2000
Vuosi on karkausvuosi.

Scanner lukija = new Scanner(System.in);
int luku = Integer.parseInt(lukija.nextLine());

if (luku % 4 != 0) {
    System.out.println("Vuosi ei ole karkausvuosi.");
} else if (...) {
    ...
} ...

Toistaminen

Tietokone on erittäin tehokas asioiden toistaja.

Toistolause ja ikuinen toisto

Toistolause sisältää lausekkeen, jonka perusteella päätellään jatketaanko toistoa, sekä lohkon, joka sisältää toistettavan lähdekoodin. Toistolauseen muoto on seuraava.

while (lauseke) {
    // lohkon sisältö
}

Lausekkeen arvon tulee evaluoitua totuusarvoiseksi muuttujaksi. Jos lausekkeen arvoksi asettaa arvon true, toistoa jatketaan ikuisesti. Seuraava ohjelma tulostaa merkkijonoa osaan ohjelmoida! ikuisesti eli "äärettömän monta kertaa":

while (true) {
    System.out.println("osaan ohjelmoida!");
}

Ikuisen toiston sisältävä ohjelma ei sammu itsestään. Ohjelman sammutus tapahtuu NetBeansissa tulostusikkunan vasemmalla puolella olevaa punaista nappia painamalla.

Toistolauseen päättäminen

Toistolauseen saa päätettyä komennolla break. Kun tietokone suorittaa komennon break, siirtyy se toistolauseen lohkoa seuraavan komennon suorittamiseen.

Scanner lukija = new Scanner(System.in);

while (true) {
    System.out.println("osaan ohjelmoida!");

    System.out.print("jatketaanko (positiivinen luku jatkaa)? ");
    int komento = Integer.parseInt(lukija.nextLine());
    if (komento <= 0) {
        break;
    }
} // lohko päättyy

// toistolauseen lohkoa seuraava komento
System.out.println("kiitos ja kuulemiin.");

Yllä olevassa esimerkissä toisto etenee siten että ensin tulostuu osaan ohjelmoida! ja tämän jälkeen ohjelma kysyy käyttäjältä jatketaanko vielä. Jos käyttäjä syöttää nollan tai negatiivisen luvun, suoritetaan komento break. Tällöin suoritus siirtyy toistolausetta seuraavaan komentoon, joka tulostaa merkkijonon kiitos ja kuulemiin.

osaan ohjelmoida!
jatketaanko (negatiivinen luku lopettaa)? 5
osaan ohjelmoida!
jatketaanko (negatiivinen luku lopettaa)? 2
osaan ohjelmoida!
jatketaanko (negatiivinen luku lopettaa)? -1
kiitos ja kuulemiin.

Syötä luku 5
Syötä luku 744
Syötä luku 22
Syötä luku -1
Syötä luku 4

Muuttujat toistolauseen ulkopuolella

Toistolauseissa halutaan usein laskea asioita. Tällöin ohjelmoijan tulee määritellä laskettavien asioiden ylläpitoon muuttuja ennen toistolauseen alkua, jotta muuttujan arvoa voidaan päivittää toistolauseessa. Alla olevassa esimerkissä ohjelma laskee syötettyjen ykkösten lukumäärän. Syötteiden lukeminen lopetetaan kun käyttäjä syöttää luvun 0.

Scanner lukija = new Scanner(System.in);

int ykkosia = 0;

while (true) {
    System.out.print("Syötä luku (0 lopettaa): ");
    int luku = Integer.parseInt(lukija.nextLine());
    if (luku == 0) {
        break;
    }

    if (luku == 1) {
        ykkosia = ykkosia + 1;
    }
}

System.out.println("Ykkösiä yhteensä: " + ykkosia);

Syötä luku 1
Syötä luku 2
Syötä luku 1
Syötä luku -1
Syötä luku 0
Ykkösiä yhteensä: 2

Yhteenveto

Ensimmäinen osa käsitteli ohjelmoinnin ja tietokoneiden toiminnan kannalta oleellisia ydinasioita. Näitä ovat muuttujat ja tieto, laskeminen, syötteen käsittely ja lukeminen, vertailu ja päätösten tekeminen sekä toistaminen.

Tehdään ensimmäisen osan loppuun vielä ohjelma, missä kerrataan ydinasioita.

Paroni von Münchhausen oli Saksan Hannoverissa syntynyt 1700-luvulla elänyt herrasmies. Hänet muistetaan ensisijaisesti sotakertomuksistaan, joista yksi liittyi tykinkuulalla lentämiseen. Oletetaan tässä, että Paronin istuimena käyttämä kuula ammuttiin tykillä suoraan ylöspäin ja tykinkuulan lähtönopeus on 1700-luvulle tyypillinen noin 400 metriä sekunnissa. Kirjoitetaan ohjelma, joka kertoo Paronin korkeuden ja nopeuden sekunti sekunnilta. Ohjelman suorituksen tulee loppua kun Paroni palaa takaisin maahan. Tämän jälkeen ohjelman tulee vielä kertoa suurin Paronin saavuttama korkeus.

Yllä kuvatun ongelman ratkaisu kannattaa tehdä useammassa osassa. Tarvitsemme toistolauseen, missä korkeuden muutosta tarkastellaan sekunti sekunnilta. Tarvitsemme ohjelmaan myös Paronin lentoon vaikuttavan painovoiman. Lopulta tarvitsemme muuttujan, mitä käytetään suurimman korkeuden tarkasteluun.

Tehdään ensin ikuisesti jatkuva ohjelma, joka tulostaa korkeuden sekunti sekunnilta. Tässä kohdassa emme vielä ota painovoimaa huomioon emmekä pyri selvittämään suurinta korkeutta.

int sekunteja = 0;
int nopeus = 400;
int korkeus = 0;

System.out.println("Sekunnit: " + sekunteja);
System.out.println("Nopeus: " + nopeus);
System.out.println("Korkeus: " + korkeus);

while (true) {
    korkeus = korkeus + nopeus;
    sekunteja = sekunteja + 1;

    System.out.println("");
    System.out.println("Sekunnit: " + sekunteja);
    System.out.println("Nopeus: " + nopeus);
    System.out.println("Korkeus: " + korkeus);
}

Sekunnit: 0
Nopeus: 400
Korkeus: 0

Sekunnit: 1
Nopeus: 400
Korkeus: 400

Sekunnit: 2
Nopeus: 400
Korkeus: 800

...

Ensimmäinen osa toimii toivotulla tavalla. Lisätään seuraavaksi ohjelmaan painovoima.

Saatamme muistaa fysiikan oppitunneilta, että maan painovoima on noin 9,81 m/s². Käytännössä siis painovoima hidastaa tykinkuulan (ja Paronin) nopeutta joka sekunti noin 9,81 metrillä -- ohjelmallisesti tämän voi toteuttaa vähentämällä nopeus-muuttujasta 9.81 jokaisella toiston kierroksella.

while (true) {
    korkeus = korkeus + nopeus;
    sekunteja = sekunteja + 1;
    nopeus = nopeus - 9.81;
    // ...
}

Mutta! Muuttuja nopeus on kokonaisluku. Emme voi vähentää kokonaisluvusta liukulukua. Muutetaan ohjelmaa siten, että muuttuja nopeus on liukuluku -- vastaava muutos tehdään muuttujalle korkeus, sillä myös siihen lisätään liukuluku.

int sekunteja = 0;
double nopeus = 400;
double korkeus = 0;

System.out.println("Sekunnit: " + sekunteja);
System.out.println("Nopeus: " + nopeus);
System.out.println("Korkeus: " + korkeus);

while (true) {
    korkeus = korkeus + nopeus;
    sekunteja = sekunteja + 1;
    nopeus = nopeus - 9.81;

    System.out.println("");
    System.out.println("Sekunnit: " + sekunteja);
    System.out.println("Nopeus: " + nopeus);
    System.out.println("Korkeus: " + korkeus);
}

Sekunteja: 0
Nopeus: 400.0
Korkeus: 0.0

Sekunnit: 1
Nopeus: 390.19
Korkeus: 400.0

Sekunnit: 2
Nopeus: 380.38
Korkeus: 790.19

...

Ohjelmassa on nyt sekä sekuntikohtainen nopeuden ja korkeuden tarkastelu sekä painovoima. Ohjelman suoritus ei kuitenkaan koskaan lopu.

Lisätään toistolauseeseen lopetusehto, missä toistolauseesta poistutaan jos korkeus on negatiivinen. Tämä tarkoittaa käytännössä sitä, että Paroni on päässyt takaisin maan pinnalle.

int sekunteja = 0;
double nopeus = 400;
double korkeus = 0;

System.out.println("Sekunnit: " + sekunteja);
System.out.println("Nopeus: " + nopeus);
System.out.println("Korkeus: " + korkeus);

while (true) {
    if (korkeus < 0) {
        break;
    }

    korkeus = korkeus + nopeus;
    sekunteja = sekunteja + 1;
    nopeus = nopeus - 9.81;

    System.out.println("");
    System.out.println("Sekunnit: " + sekunteja);
    System.out.println("Nopeus: " + nopeus);
    System.out.println("Korkeus: " + korkeus);
}

Sekunteja: 0
Nopeus: 400.0
Korkeus: 0.0

Sekunnit: 1
Nopeus: 390.19
Korkeus: 400.0

Sekunnit: 2
Nopeus: 380.38
Korkeus: 790.19

... monta riviä

Sekunnit: 83
Nopeus: -414.23000000000013
Korkeus: -183.4300000000065

Ohjelma käy nyt sekunti sekunnilta Paronin korkeuden ja nopeuden. Edellä annetun esimerkkitulosteen perusteella Paroni palaa maahan hieman yli 400 metrin sekuntivauhtia (eli hieman yli 1400 kilometriä tunnissa).

Selvitetään vielä lopuksi Paronin lennon suurin korkeus. Haluamme tulostaa korkeuden ohjelman lopussa, eli toistolauseen jälkeen. Tarvitsemme käytännössä uuden muuttujan, jonka tehtävänä on säilöä suurin korkeus. Muuttujan arvo päivitetään tarvittaessa toistolauseessa aina korkeuden päivityksen jälkeen.

double suurinkorkeus = 0;

int sekunteja = 0;
double nopeus = 400;
double korkeus = 0;

System.out.println("Sekunnit: " + sekunteja);
System.out.println("Nopeus: " + nopeus);
System.out.println("Korkeus: " + korkeus);

while (true) {
    if (korkeus < 0) {
        break;
    }

    korkeus = korkeus + nopeus;
    sekunteja = sekunteja + 1;
    nopeus = nopeus - 9.81;

    if (korkeus > suurinkorkeus) {
        suurinkorkeus = korkeus;
    }

    System.out.println("");
    System.out.println("Sekunnit: " + sekunteja);
    System.out.println("Nopeus: " + nopeus);
    System.out.println("Korkeus: " + korkeus);
}

System.out.println("");
System.out.println("Suurin korkeus: " + suurinkorkeus);

Sekunteja: 0
Nopeus: 400.0
Korkeus: 0.0

Sekunnit: 1
Nopeus: 390.19
Korkeus: 400.0

Sekunnit: 2
Nopeus: 380.38
Korkeus: 790.19

... monta riviä

Sekunnit: 83
Nopeus: -414.23000000000013
Korkeus: -183.4300000000065

Suurin korkeus: 8355.8

Paroni olisi päässyt esimerkissämme siis lähes 83 sekunnin lentomatkalle sekä yli kahdeksan kilometrin korkeuteen.

Tykinkuula

Tässä tehtävässä luot edellä kuvatun ohjelman suoraan ylöspäin ammutun tykinkuulan suurimman korkeuden selvittämiseen. Ohjelmassa on kuitenkin muutamia parannuksia: käyttäjä voi syöttää sekä lähtönopeuden että painovoiman. Tämän lisäksi tulostuksessa arvot on eroteltu sarkaimilla, mikä mahdollistaa niiden helpon siirtämisen esimerkiksi taulukkolaskentaohjelmiin.

Tässä muutamia vinkkejä tehtävän tekemisen helpottamiseen.

Vinkki 1. Saat luettua käyttäjältä liukuluvun komennolla Double.parseDouble(lukija.nextLine()). Ohjelmassa tämä tapahtuu seuraavasti.

Scanner lukija = new Scanner(System.in);

System.out.println("Syötä liukuluku");
double luku = Double.parseDouble(lukija.nextLine());
System.out.println("Syötetty: " + luku);

Syötä liukuluku
8.91
Syötetty: 8.91

Vinkki 2. Saat tulostettua arvoja sarkaimilla erotettuna erikoismerkin "\t" avulla.

int sekunteja = 0;
double korkeus = 0;
double suurinkorkeus = 0;

System.out.println(sekunteja + "\t" + korkeus + "\t" + nopeus);

0    0.0    0.0

Tehtävänäsi on siis toteuttaa ohjelma, joka kysyy käyttäjältä tykinkuulan lähtönopeutta ja painovoimaa. Ohjelman tulee tulostaa tykinkuulan korkeus sekunti sekunnilta kunnes tykinkuula palaa maahan. Ohjelman tulee lisäksi ohjelman lopussa kertoa tykinkuulan suurin korkeus.

Ohjelman tulostuksen tulee olla seuraavanlainen. Alla olevassa esimerkissä lähtönopeudeksi on syötetty 42.0 ja painovoimaksi 9.81.

Syötä tykinkuulan lähtönopeus:
42.0
Syötä painovoima:
9.81

0	0.0	42.0
1	42.0	32.19
2	74.19	22.379999999999995
3	96.57	12.569999999999995
4	109.13999999999999	2.7599999999999945
5	111.89999999999998	-7.050000000000006
6	104.84999999999997	-16.860000000000007
7	87.98999999999995	-26.67000000000001
8	61.31999999999994	-36.48000000000001
9	24.839999999999932	-46.29000000000001

Tykinkuulan suurin korkeus oli 111.89999999999998

Alla olevassa esimerkissä taas oletetaan, että lähtönopeus on 15 ja painovoima 3.5.

Syötä tykinkuulan lähtönopeus:
15
Syötä painovoima:
3.5

0	0.0	15.0
1	15.0	11.5
2	26.5	8.0
3	34.5	4.5
4	39.0	1.0
5	40.0	-2.5
6	37.5	-6.0
7	31.5	-9.5
8	22.0	-13.0
9	9.0	-16.5

Tykinkuulan suurin korkeus oli 40.0

Huom! Vaikka edellä on syötettynä lähtönopeudeksi kokonaisluku, voi sen silti ohjelmassa toteuttaa niin, että luku asetetaan desimaalilukuun. Komento Double.parseDouble(lukija.nextLine()) siis toimi, vaikka käyttäjä syöttäisi kokonaisluvun.

Kun ohjelman suoritus on valmis, voit kokeilla lukujen syöttämistä taulukkolaskentaohjelmaan. Alla oleva tykinkuulan korkeuden kuvaaja on luotu edellisen esimerkin tulosteesta Google Driven avulla.