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 selitystehtäviä ja koodinlukutehtäviä. Kukin selitystehtävä on kahden yksittäisen tehtävän arvoinen kurssipisteytyksessä. Koodinlukutehtävät taas on tarkoitettu lähinnä kertaamista varten.

Alla on kaksi esimerkkiä koodinlukutehtävästä. Kun avaat tehtävän 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, jolloin voit myös kerrata lukemista. Kokeile tehtäviä!

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 :). Voit testata allaolevaa selitystehtävää.

10 Muuttuvat muuttujat

Huomattava osa edellisellä viikolla tekemistämme ohjelmista käytti muuttujia. 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 halutaan usein muuttaa. Tämä onnistuu tavallisen sijoituslausekkeen avulla. Seuraavassa 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 muuttuja 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. Miksi?

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 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);

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

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

12 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. 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 takaisin koodiin siihen kohtaan 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 metodin lukija.nextLine 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.

13 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 Esimerkki {
    public static void main(String[] args) {
        Scanner lukija = new Scanner(System.in);
        // ohjelmakoodi
    }

    // omia metodeja 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 Esimerkki {
    public static void main(String[] args) {
        Scanner lukija = new Scanner(System.in);
        // ohjelmakoodi
    }

    // omia metodeja tänne
    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 metodissa olevat koodirivit, jonka jälkeen palataan kohtaan, josta metodin kutsu tapahtui. Tarkemmin ottaen metodikutsun jälkeiselle riville.

Jos ollaan tarkkoja niin pääohjelma eli main on 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.

Metodien nimennästä

Metodit nimetään siten, että ensimmäinen sana kirjoitetaan pienellä ja loput alkavat isolla alkukirjaimella, tälläisestä kirjoitustavasta käytetään nimitystä camelCase. Tämän lisäksi, metodin sisällä koodi on sisennetty taas neljä merkkiä.

public static void Tama_metodi_sanoo_mur ( ) {
System.out.println("mur");
}
        

public static void tamaMetodiSanooMur() {
    System.out.println("mur");
}
        

13.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 Verna ja toisella kutsulla Chang.

public static void main(String[] args) {
    tervehdi("Verna");
    tervehdi("Chang");
}

Hei Verna, terveiset metodimaailmasta!
Hei Chang, 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 = "Ilari";
    String nimi2 = "S";
    tervehdi(nimi1 + " " + nimi2);

    int ika = 20;
    tervehdi("Jani " + ika + " vuotta");
}

Hei Ilari S, terveiset metodimaailmasta!
Hei Jani 20 vuotta, terveiset metodimaailmasta!

Molemmissa tapauksissa metodilla on edelleen vain 1 parametri. Jos parametri on lause, kuten esimerkiksi nimi1 + " " + nimi2, lasketaan lauseen arvo ennen metodin kutsumista. Ensimmäisessä tapauksessa parametrin arvo saadaan merkkijonokatenaationa nimi1 + " " + nimi2 joka siis on arvoltaan Ilari S ja jälkimmäisessä tapauksessa merkkijonokatenaatiosta "Jani " + ika + " vuotta".

13.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

13.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("Ada-Maaria", 3);
    System.out.println("ja");
    tervehdiMontaKertaa("Juha", 2);
}

Tulostuu:

Hei Ada-Maaria, terveiset metodimaailmasta!
Hei Ada-Maaria, terveiset metodimaailmasta!
Hei Ada-Maaria, terveiset metodimaailmasta!
ja
Hei Juha, terveiset metodimaailmasta!
Hei Juha, 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!