Tämä materiaali on lisensoitu Creative Commons BY-NC-SA-lisenssillä, joten voit käyttää ja levittää sitä vapaasti, kunhan alkuperäisten tekijöiden nimiä ei poisteta. Jos teet muutoksia materiaaliin ja haluat levittää muunneltua versiota, se täytyy lisensoida samanlaisella vapaalla lisenssillä. Materiaalien käyttö kaupalliseen tarkoitukseen on ilman erillistä lupaa kielletty.
Tekijät: Arto Vihavainen ja Matti Luukkainen
Tämä materiaali on tarkoitettu Helsingin yliopiston tietojenkäsittelytieteen laitoksen Ohjelmoinnin perusteet -kurssille. Materiaali pohjautuu syksyn 2012 ja keväiden 2013, 2012, 2011 ja 2010 kurssimateriaaleihin, joiden sisältöön ovat vaikuttaneet Matti Paksula, Antti Laaksonen, Pekka Mikkola, Juhana Laurinharju, Martin Pärtel, Joel Kaasinen ja Mikael Nousiainen.
Lue materiaalia siten, että teet samalla itse kaikki lukemasi esimerkit. Esimerkkeihin kannattaa tehdä pieniä muutoksia ja tarkkailla, miten muutokset vaikuttavat ohjelman toimintaan. Äkkiseltään voisi luulla, että esimerkkien tekeminen myös itse ja niiden muokkaaminen hidastaa opiskelua. Tämä ei kuitenkaan pidä ollenkaan paikkansa. Ohjelmoimaan ei ole vielä tietääksemme kukaan ihminen oppinut pelkästään lukemalla (tai esim. luentoa kuuntelemalla). Oppiminen perustuu oleellisesti aktiiviseen tekemiseen, rutiinin kasvattamiseen sekä opittavien asioiden pohtimiseen ja itselleen ja muille selittämiseen. Esimerkkien ja erityisesti erilaisten omien kokeilujen tekeminen on parhaita tapoja "sisäistää" luettua tekstiä. TMC:ssä on kokeiluja varten tehtäväpohja, jonka nimi on "Hiekkalaatikko".
Pyri tekemään tai ainakin yrittämään tehtäviä sitä mukaa kuin luet tekstiä. Jos et osaa heti tehdä jotain tehtävää, älä masennu, sillä saat ohjausta tehtävän tekemiseen IRC:ssä kanavilla #ohpe ja #mooc.fi sekä pajassa.
Tekstiä ei ole tarkoitettu vain kertaalleen luettavaksi. Joudut varmasti myöhemmin palaamaan jo aiemmin lukemiisi kohtiin tai aiemmin tekemiisi tehtäviin. Tämä teksti ei sisällä kaikkea oleellista ohjelmointiin liittyvää. Itse asiassa ei ole olemassa mitään kirjaa josta löytyisi kaikki oleellinen. Eli joudut joka tapauksessa ohjelmoijan urallasi etsimään tietoa myös omatoimisesti. Kurssin harjoitukset sisältävät jo jonkun verran ohjeita, mistä suunnista ja miten hyödyllistä tietoa on mahdollista löytää.
Muutamiin kohtiin olemme myös liittäneet screencasteja, eli videoita, joita katsomalla voi pelkän valmiin koodin lukemisen sijaan seurata miten ohjelma muodostuu. Tämän lisäksi materiaalissa on kyselyjä, joiden vastauksia käytetään osana Helsingin yliopistolla tehtävää ohjelmoinnin oppimisen tutkimusta. Kyselyt ja tehtävät saa auki klikkaamalla kyselyn tai tehtävän nimeä.
Kurssilla on kahdenlaisia tehtäviä, joiden tekemisestä saa viikoittaisia tehtäväpisteitä. Ensimmäisellä viikolla alkavat ohjelmointitehtävät, ja toisesta viikosta lähtien ohjelmointitehtävien lisäksi materiaalissa on myös selitystehtäviä, joissa annettuun kysymykseen tai ongelmaan tulee kirjoittaa selitys ohjeiden mukaan. Kaksi kolmasosaa kurssin kokonaispistemäärästä tulee näiden tehtävien tekemisestä, viimeinen kolmasosa tulee kurssikokeesta. Katso kurssisivulta tarkempaa tietoa viikoittaisesta pisteytyksestä.
Ohjelmointi- ja selitystehtävien lisäksi materiaalissa on tutkimuskysymyksiä ja kyselyitä. Vastaamalla rehellisesti kaikkiin materiaalissa oleviin tutkimuskysymyksiin ja -kyselyihin voit saada neljä ylimääräistä tehtäväpistettä, joilla voi esimerkiksi paikata tekemättä jääneitä tehtäviä tai mahdollisia pulmia kokeessa. Kokeesta tulee näistä neljästä ylimääräisestä pisteestä huolimatta saada kuitenkin vähintään puolet pisteistä kurssin läpäisemiseen. Varmistathan kyselyihin vastatessa että käytät TMC-tunnustasi, jolloin voimme kytkeä vastauksesi kurssipisteisiin.
Näet tehtävien ja kyselyjen sisällön klikkaamalla niiden nimeä.
Tietokoneohjelmia verrataan usein leipomiseen. Tietokone on leipuri, tietokone-ohjelma resepti, ja tietokoneen resurssit -- esimerkiksi näyttö ja verkkokortti -- raaka-aineita. Leipurilla ja tietokoneella on kuitenkin merkittävä ero siinä, että vaikka leipuri kehittyy reseptejä toistaessa ja voi esimerkiksi soveltaa uusia raaka-aineita, tietokone ei tiedä mitä se tekee, eikä se myöskään osaa soveltaa. Tietokone noudattaa ohjeita säntillisesti, jopa tyhmästi, eikä osaa reagoida vaikkapa rikkinäiseen uuniin, ellei resepti ota huomioon uunin rikkoutumismahdollisuutta ja kerro täsmällisesti mitä uunin rikkoutuessa tulee tehdä.
Toisin kuin leipuri, tietokone ei myöskään kehity siinä mielessä, että se oppisi virheistä. Ohjelmoijat, reseptien -- tai lähdekoodin -- kehittäjät, onneksi kuitenkin oppivat ja kehittyvät.
Ohjelma -- resepti -- muodostuu lähdekoodista. Tietokone suorittaa lähdekoodissa olevia komentoja pääsääntöisesti rivi riviltä ylhäältä alaspäin ja vasemmalta oikealle. Lähdekoodi on ohjelmoijan kirjoittamaa, ja se tallennetaan tekstimuodossa.
Varsinaisesti ohjelma muodostuu lähdekoodiin kirjoitetuista komennoista. Tietokone suorittaa komentojen perusteella operaatioita, eli toimintoja. Esimerkiksi tekstin (merkkijono) "Hei maailma"-tulostuksessa tärkein komento on System.out.println
.
System.out.println("Hei maailma");
Komento System.out.println
tulostaa sille sulkeiden sisällä hipsuissa annetun merkkijonon. Komennon pääte ln
on lyhenne sanasta line, ja komento tulostaa annetun merkkijonon jälkeen myös rivinvaihdon.
Tietokone ei ymmärrä ohjelmointikieltä suoraan. Tarvitsemme lähdekoodin ja tietokoneen väliin kääntäjän, joka kääntää ohjelman tietokoneen ymmärtämään muotoon. Java-ohjelmointikielisen ohjelman voi kääntää komentoriviä käyttäen komennolla javac Hei.java
, mikä kääntää Hei.java
-nimisen tiedoston sisältämän lähdekoodin tietokoneen ymmärtämäksi tavukoodiksi, jota voidaan ajaa java-tulkin avulla. Käännetty ohjelma ajetaan komentoriviltä komennolla java Hei
, missä Hei on käännetyn java-lähdekooditiedoston nimi.
Käyttäessämme nykyaikaista ohjelmointiympäristöä, ohjelmointiympäristö hoitaa lähdekoodin kääntämisen puolestamme. Valitessamme ohjelman suorittamisen, ohjelmointiympäristö kääntää ja suorittaa ohjelman automaattisesti, ilman että näemme tätä välivaihetta. Ohjelmointiympäristöt kääntävät ohjelmakoodia ohjelmoijan sitä kirjoittaessa, jolloin yksinkertaiset virheet huomataan ja merkitään ohjelmointiympäristössä näkyvään lähdekoodiin esimerkiksi punaisella alleviivauksella.
Puolipisteellä ;
erotetaan komennot toisistaan. Kääntäjä ja tulkki ei ole kiinnostunut lähdekoodissa olevista riveistä, vaan voisimme kirjoittaa koko ohjelman yhdelle riville -- mikä ei kuitenkaan olisi kovin ymmärrettävää.
Alla olevassa esimerkissä käytetään komentoa System.out.print
, joka on kuten komento System.out.println
ilman rivinvaihtoa. System.out.print
-komento ei siis tulosta rivinvaihtoa tekstin tulostamisen jälkeen.
Esimerkki puolipisteiden käytöstä
System.out.print("Hei "); System.out.print("maailma"); System.out.print("!");
Hei maailma!
Vaikka kääntäjä ja tulkki eivät tarvitse rivinvaihtoja, on niiden käyttö hyvin tärkeää muita ihmisiä ajatellen. Selkeä lähdekoodin osien erottelu vaatii rivinvaihtojen käyttöä. Tätä ja muita lähdekoodin luettavuuteen liittyviä seikkoja tullaan painottamaan tällä kurssilla.
Komennon käsittelemä tieto eli komennon parametrit lähetetään komennolle lisäämällä ne komennon nimen perässä olevien sulkujen ()
sisään. Esimerkiksi System.out.print
-komennon parametriksi annetaan merkkijono hei hipsujen sisällä seuraavasti: System.out.print("hei")
.
Lähdekoodin kommentit
ovat kätevä tapa merkitä asioita itselle ja muille muistiin. Kommentti on mikä tahansa rivi, joka alkaa kahdella vinoviivalla //
. Kaikki kommenttimerkkiä seuraava samalla rivillä oleva teksti tulkitaan kommentiksi.
// Tulostamme tekstin "Hei maailma" System.out.print("Hei maailma"); System.out.print(" ja kaikki sen ihmiset."); // Lisäämme samalle riville tekstiä. // System.out.print("tätä riviä ei suoriteta koska se on kommentoitu ulos");
Esimerkissä alin rivi esittelee erityisen kätevän käyttökohteen kommenteille: kirjoitettua koodia ei tarvitse poistaa jos haluaa tilapäisesti kokeilla jotain.
Kuten aiemmin huomattiin, tulostamiseen on kaksi komentoa:
System.out.print("sana");
tulostaa tekstin "sana" ilman loppurivinvaihtoaSystem.out.println("sana");
tulostaa tekstin "sana" ja loppurivinvaihdonTulostettavan tekstin osana voi olla erikoismerkkejä. Tärkein näistä on \n
, joka vaihtaa riviä. Erikoismerkkejä on muitakin.
System.out.println("Ensimmäinen\nToinen\nKolmas");
Ylläoleva komento tulostaa suoritettaessa seuraavaa:
Ensimmäinen Toinen Kolmas
Ohjelman "Esimerkki" runko on seuraavanlainen.
public class Esimerkki { public static void main(String[] args) { // ohjelmakoodi ja komennot } }
Ohjelma sijaitsee .java-päätteisessä tiedostossa, jonka nimi on sama kuin ohjelman nimi -- tässä esimerkki -- "public class Esimerkki". Ohjelman Esimerkki täytyy siis sijaita tiedostossa, jonka nimi on Esimerkki.java
.
Ohjelmaa suoritettaessa suoritetaan alue, joka on rungossamme merkitty kommentilla ohjelmakoodi ja komennot. Ohjelmoimme ensimmäisellä viikolla vain tälle alueelle. Kun puhumme komennoista, esimerkiksi tulostamisesta, tulee komennot kirjoittaa ohjelmarungon sisälle. Esimerkiksi System.out.print("Tulostettava teksti");
public class Esimerkki { public static void main(String[] args) { System.out.print("Tulostettava teksti"); } }
Jatkossa esimerkeissä ei aina erikseen näytetä pääohjelmarunkoa, mutta voit olettaa, että se tarvitaan.
Vaikka tietokone ja käyttämämme ohjelmointikieli ei aseta rajoituksia kirjoitettavan ohjelmakoodin ulkoasulle, olemme osana ohjelmoinnin opetuksen ja oppimisen tutkimista huomanneet että ohjelmoijan -- tai opiskelevan ohjelmoijan -- kirjoittaman koodin ulkoasulla on merkitystä myös oppimisen kannalta. Esimerkiksi lähdekoodin 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.print("Heippa vaan! Tämä koodi on siististi sisennetty."); System.out.print("public class -- ei sisennystä."); System.out.print("public static -- neljän merkin sisennys."); System.out.print("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.print("Heippa vaan! Tämä koodi on siististi sisennetty."); System.out.print("public class -- ei sisennystä."); System.out.print("public static -- neljän merkin sisennys."); System.out.print("public static ... sisällä -- kahdeksan merkin sisennys -- tai enemmän.");}}
Kurssilla käytettävässä Test My Code-ympäristössä tulee mukana Checkstyle-niminen työväline, joka ohjaa hyvään ohjelmointityyliin. Checkstyle tarkistaa mm. koodin sisennystä, metodien nimeämistä, tyhjiä lohkoja ja paljon muuta -- kurssin edetessä nämä käsitteet tulevat tutuiksi. Tällä kurssilla Checkstyle tarkistaa lähes ainoastaan tyylivirheitä -- ohjeita tulee kurssin edetessä.
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 auttaa useimpien tyylivirheiden korjaamiseen, on koodia syytä kirjoittaa oikein alusta alkaen.
Nykyaikainen ohjelmointi tapahtuu lähes poikkeuksetta ohjelmointiympäristössä. Ohjelmointiympäristö sisältää joukon ohjelmoijaa auttavia aputoimintoja. Ohjelmointiympäristö ei rakenna ohjelmaa ohjelmoijan puolesta, mutta se muunmuassa vinkkaa helpoista virheistä ohjelmakoodissa ja auttaa ohjelmoijaa hahmottamaan ohjelman rakennetta.
Käytämme tällä kurssilla NetBeans-nimistä ohjelmointiympäristöä. Ohje ohjelmoinnin aloittamiseen NetBeans-ohjelmointiympäristössä löytyy täältätäältä.
Jatkossa julkaisemme pikkuhiljaa lisää ohjeita NetBeansin käyttöön. Vaikka ohjelma tuntuisi nyt sekavalta, älä hätäile. NetBeans on loppujenlopuksi hyvin helppokäyttöinen. Perusteet opit 5 minuutissa, ja kurssin myötä opit koko ajan hieman lisää ja kesäkuussa olet jo todellinen NetBeans "poweruser".
Ennen kuin tiedät mitä teet, toimi täsmälleen ohjeen kuvaamalla tavalla. Useimmat seuraavista tehtävänannoista näyttävät mitä pyydetyn tehtävän tulisi tulostaa ruudulle toimiakseen oikein.
HUOM: älä tee tehtäviä siten että pelkästään kirjoitat koodia ja painelet testinappia. Suorita myös koodia normaaliin tapaan (vihreällä nuolella) ja katso mitä ruudulle tulostuu. Erityisesti jos ohjelma ei meinaa mennä testeistä läpi, kannattaa varmistaa normaalisti suorittamalla että ohjelma toimii silmämääräisesti niinkuin sen pitäisi.
Seuraavissa tehtävissä harjoitellaan tuntuman saamista NetBeansiin ja ruudulle tulostamista.
Muista ensin katsoa ohje NetBeansin käyttöön täältä
Jos et ole vielä käynyt vastaamassa taustatietokyselyyn, tee se NYT klikkaamalla tästä
Näet tehtävänannon klikkaamalla tehtävän nimeä
Tee ohjelma, joka tulostaa nimesi.
Ohjelman tulostus voi olla seuraava:
Oskari Opiskelija
Tee ohjelma, jonka tulostus on seuraava:
Hei Maailma! (Ja Mualima!)
Tee ohjelma, jonka tulostus on seuraava:
* *** ***** ******* ********* *
HUOM: kirjoitit todennäköisesti aika monta kertaa System.out.println("...")
. Kokeile kirjoittaa NetBeans:iin (main:in sisään) tyhjälle riville sout ja paina tabulaatoria (näppäin q:n vasemmalla puolella). Mitä tapahtuu? Tämä pieni apuväline säästänee jatkossa runsaasti aikaasi.
Ohjelmoinnissa eräs keskeinen käsite on muuttuja. Muuttuja kannattaa ajatella lokerona, johon voi tallettaa tietoa. Muuttujaan talletettavalla tiedolla on aina tyyppi. Tyyppejä ovat esimerkiksi teksti eli merkkijono (String), kokonaisluku (int), liukuluku (double) ja totuusarvo (boolean). Muuttujaan asetetaan arvo yhtäsuuruusmerkillä (=
).
int kuukausia = 12;
Yllä olevassa asetuslauseessa asetetaan kokonaisluku-tyyppiä (int) olevaan muuttujaan nimeltä kuukausia arvo 12. Asetuslause luetaan "muuttuja kuukausia saa arvon 12".
Muuttujan arvo voidaan yhdistää merkkijonoon +
-merkillä
seuraavan esimerkin mukaisesti.
String teksti = "sisältää tekstiä"; int kokonaisluku = 123; double liukuluku = 3.141592653; boolean onkoTotta = true; System.out.println("Tekstimuuttujan arvo on " + teksti); System.out.println("Kokonaislukumuuttujan arvo on " + kokonaisluku); System.out.println("Liukulukumuuttujan arvo on " + liukuluku); System.out.println("Totuusarvomuuttujan arvo on " + onkoTotta);
Tulostus:
Tekstimuuttujan arvo on sisältää tekstiä Kokonaislukumuuttujan arvo on 123 Liukulukumuuttujan arvo on 3.141592653 Totuusarvomuuttujan arvo on true
Muuttuja säilyttää arvonsa kunnes siihen asetetaan toinen arvo. Huomaa että muuttujan tyyppi kirjoitetaan vain kun muuttuja esitellään ohjelmassa ensimmäistä kertaa.
int kokonaisluku = 123; System.out.println("Kokonaislukumuuttujan arvo on " + kokonaisluku); kokonaisluku = 42; System.out.println("Kokonaislukumuuttujan arvo on " + kokonaisluku);
Tulostuu:
Kokonaislukumuuttujan arvo on 123 Kokonaislukumuuttujan arvo on 42
Kun muuttujan tyyppi on kertaalleen määritelty, ei se enää muutu. Esimerkiksi merkkijonomuuttuja ei voi muuttua kokonaislukumuuttujaksi, eikä siihen voi asettaa kokonaislukua.
String merkkijono = "tsuppadui!"; merkkijono = 42; // Ei onnistu! :(
Liukulukuun voi asettaa kokonaisluvun, sillä kokonaisluku on myös liukuluku
double liukuluku = 0.42; liukuluku = 1; // Onnistuu! :)
Tehtäväpohja sisältää ohjelman, joka tulostaa seuraavaa.
Kanoja: 3 Pekonia (kg): 5.5 Traktori: Ei ole! Tässä vielä tiivistelmä: 3 5.5 Ei ole!
Muuta ohjelmaa annetuista kohdista niin että tuloste on:
Kanoja: 9000 Pekonia (kg): 0.1 Traktori: Zetor Tässä vielä tiivistelmä: 9000 0.1 Zetor
Muuttujan nimeämistä rajoittavat tietyt ehdot. Vaikka muuttujan nimessä voidaan käyttää ääkkösiä, on parempi olla kayttamatta niita, sillä merkistökoodauksesta saattaa tulla ongelmia.
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 myöskään saa olla jo entuudestaan käytössä. Tälläisiä nimiä ovat mm. aikaisemmin määritellyt muuttujat ja komennot, kuten System.out.print
ja System.out.println
.
int camelCase = 2; int camelCase = 5; // Ei sallittu -- muuttuja camelCase on jo käytössä!
Muuttuja kannattaa nimetä siten, että sen käyttötarkoitus on selvää ilman kommentteja tai miettimistä. Tällä kurssilla muuttujat pitää nimetä kuvaavasti.
Laskentaoperaatiot ovat varsin suoraviivaisia: +
, -
, *
ja /
. Erikoisempana operaationa on %
, joka on jakojäännös, eli modulo. Laskentajärjestys on myös varsin suoraviivainen: operaatiot lasketaan vasemmalta oikealle sulut huomioon ottaen. Kuitenkin *
ja /
laskentaan ennen +
ja -
operaatioita. Tässä vielä tarkemmin laskujärjestyksestä javassa. Linkin takana oleva materiaali ei ole kuitenkaan aloittelijan kannalta kovin oleellista.
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
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 sulkuesimerkin voi suorittaa myös askeleittain.
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
Laskentaoperaatioita voidaan suorittaa lähes missä tahansa kohdassa ohjelmakoodia.
int eka = 2; int toka = 4; System.out.println(eka + toka); // tulostaa 6 System.out.println(2 + toka - eka - toka); // tulostaa 0
Kokonaislukujen jako ja jakojäännös ovat hieman hankalampia. Liukuluku ja kokonaisluku menevät helposti sekaisin. Jos kaikki laskuoperaatiossa 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
Jakojäännös-operaation (%) avulla saadaan selville jakojäännös. Esimerkiksi laskun 7 % 2
jakojäännös on 1.
int jakojaannos = 7 % 2; System.out.println(jakojaannos); // tulostaa 1
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
Jälkimmäisessä tulos pyöristyy väärin sillä laskuoperaatio kokonaisluvuilla suoritetaan ennen tyyppimuunnosta.
Jos jakolaskun tulos asetetaan kokonaislukutyyppiseen muuttujaan, on tulos automaattisesti kokonaisluku
int tulosKokonaislukuKoskaTyyppiKokonaisluku = 3.0 / 2; // tulos automaattisesti kokonaisluku: 1
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);
Mitä seuraava tulostaa?
int jaettava = 3; int jakaja = 2; double tulos = jaettava / jakaja * 1.0; System.out.println(tulos);
Huomioi, että nimeät muuttujat nyt ja jatkossakin yllä esiteltyjen hyvien käytäntöjen mukaan.
Tee ohjelma, joka laskee, kuinka monta sekuntia on vuodessa. Voit olettaa, että vuodessa on 365 päivää (eli ei ole karkausvuosi).
Ohjelman tulostus on seuraava:
Vuodessa on X sekuntia.
X:n kohdalle tulee ohjelmasi laskema tulos.
Tarkastellaan vielä lähemmin merkkijonojen
yhdistämistä +
-merkinnän avulla.
Jos operaatiota +
sovelletaan kahden merkkijonon välille, syntyy uusi merkkijono, jossa kaksi merkkijonoa on yhdistetty. Huomaa nokkela välilyönnin käyttö lauseen "muuttujien" osana!
String tervehdys = "Hei "; String nimi = "Matti"; String hyvastely = ", ja näkemiin!"; String lause = tervehdys + nimi + hyvastely; System.out.println(lause);
Hei Matti, ja näkemiin!
Jos toinen operaation +
kohteista on merkkijono, syntyy uusi merkkijono, jossa esimerkiksi kokonaisluku 2
on muutettu merkkijonoksi "2" ja tähän yhdistetty haluttu merkkijono.
System.out.println("tuossa on kokonaisluku --> " + 2); System.out.println( 2 + " <-- tuossa on kokonaisluku");
Edellä 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
Edellisiä tietoja yhdistelemällä pystymme tulostamaan muuttujan arvoja ja tekstiä sekaisin:
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);
Tämä ohjelma tulostaa tietenkin:
muuttujan x arvo on: 10 y on 5 ja z on 6
Tee ohjelma, jonka avulla voidaan laskea kahden kokonaisluvun summa. Ohjelman alussa määritellään kaksi muuttujaa, jotka sisältävät summattavat luvut. Voit tarvittaessa käyttää myös muita muuttujia.
Esimerkiksi jos muuttujissa on luvut 5 ja 4, ohjelman tulostus on seuraava:
5 + 4 = 9
Jos taas muuttujissa on luvut 73457 ja 12888, ohjelman tulostus on seuraava:
73457 + 12888 = 86345
Tee edellistä ohjelmaa vastaava ohjelma, joka laskee kahden kokonaislukumuuttujaan sijoitetun arvon kertolaskun.
Esimerkiksi jos muuttujissa on luvut 2 ja 8, ohjelman tulostus on seuraava:
2 * 8 = 16
Jos taas muuttujissa on luvut 277 ja 111, ohjelman tulostus on seuraava:
277 * 111 = 30747
Kuinka suuren kertolaskun ohjelmasi pystyy laskemaan?
Tähän asti ohjelmamme ovat olleet kovin yksipuolisia. Seuraavaksi luemme syötettä käyttäjältä. Käytämme syötteen lukemiseen erityistä Scanner-apuvälinettä.
Lisätään Scanner valmiiseen pääohjelmarunkoomme. Älä hätäile vaikka pääohjelmarunko saattaa näyttää vaikeaselkoiselta, jatkamme koodausta kuten ennenkin, eli kohtaan mikä on merkattu kommentilla ohjelmakoodi.
import java.util.Scanner; public class OhjelmaRunko { public static void main(String[] args) { Scanner lukija = new Scanner(System.in); // ohjelmakoodi } }
Seuraava koodi lukee käyttäjän nimen ja tulostaa tervehdyksen:
System.out.print("Mikä on nimesi? "); String nimi = lukija.nextLine(); // Luetaan käyttäjältä rivi tekstiä ja asetetaan se muuttujaan nimi System.out.println("Hei, " + nimi);
Mikä on nimesi? Matti
Hei, Matti
(Seuraavassa on yllä oleva ohjelma pääohjelmarungon kanssa. Ohjelman nimi on Tervehdys. Koska ohjelman nimi on Tervehdys, täytyy sen sijaita tiedostossa Tervehdys.java
-- Käyttäessäsi NetBeans-ohjelmointiympäristöä, toimi kuten alussa olleessa
ohjeessa
ohjeessa
tehtiin, mutta muuta ohjelman nimi Heistä (Hei) Tervehdykseksi (Tervehdys)
import java.util.Scanner; public class Tervehdys { public static void main(String[] args) { Scanner lukija = new Scanner(System.in); System.out.print("Kenelle sanotaan hei: "); String nimi = lukija.nextLine(); // Luetaan käyttäjältä rivi tekstiä ja asetetaan sen arvo muuttujaan nimi System.out.print("Hei " + nimi); } }
Kun yllä oleva ohjelma ajetaan, pääset kirjoittamaan syötteen. NetBeansin tulostusvälilehti (alhaalla) näyttää ajetun ohjelman jälkeen seuraavalta (käyttäjä syöttää nimen "Matti").
run: Kenelle sanotaan hei: Matti Hei Matti BUILD SUCCESSFUL (total time: 6 seconds)
Scanner-apuvälineemme ei ole hyvä kokonaislukujen lukemiseen, joten käytämme toista apuvälinettä merkkijonon kokonaisluvuksi muuttamisessa. Komento Integer.parseInt
muuttaa sille annetussa tekstimuuttujassa olevan kokonaisluvun kokonaislukumuuttujaksi. Komennolle annetaan tekstimuuttuja sulkuihin, ja se palauttaa kokonaisluvun joka asetetaan kokonaislukumuuttujaan.
Käytännössä kytkemme kaksi komentoa yhteen. Ensin luemme käyttäjältä rivin, jonka annamme heti komennolle Integer.parseInt
.
System.out.print("Anna kokonaisluku: "); int kokonaisluku = Integer.parseInt(lukija.nextLine()); System.out.println("Annoit " + kokonaisluku);
Kysytään seuraavaksi käyttäjältä nimi, ja sen jälkeen ikä. Tällä kertaa esimerkissä on myös ohjelmarunko mukana.
import java.util.Scanner; public class NimiJaIkaTervehdys { public static void main(String[] args) { Scanner lukija = new Scanner(System.in); System.out.print("Nimesi: "); String nimi = lukija.nextLine(); // Luetaan käyttäjältä rivi tekstiä System.out.print("Kuinka vanha olet: "); int ika = Integer.parseInt(lukija.nextLine()); // luetaan käyttäjältä tekstimuuttuja ja muutetaan se kokonaisluvuksi System.out.println("Nimesi on siis: " + nimi + ", ja ikäsi " + ika + ", hauska tutustua."); } }
Käyttäjän kanssa keskustelevan ohjelman runko:
import java.util.Scanner; public class OhjelmanNimi { public static void main(String[] args) { Scanner lukija = new Scanner(System.in); // koodi tähän } }
Merkkijonon lukeminen:
String merkkijono = lukija.nextLine();
Kokonaisluvun lukeminen:
int kokonaisluku = Integer.parseInt(lukija.nextLine());
Tee ohjelma, joka kysyy käyttäjältä kaksi kokonaislukua ja tulostaa niiden summan.
Anna ensimmäinen luku: 6 Anna toinen luku: 2 Lukujen summa: 8
Esimerkissä punainen väri tarkoittaa käyttäjän kirjoittamaa tekstiä. Tätä käytäntöä noudatetaan jatkossa esimerkeissä.
Tee ohjelma, joka kysyy käyttäjältä kaksi kokonaislukua ja
tulostaa niiden osamäärän. Varmista, että 3 / 2 = 1.5
. Jos desimaaliosa katoaa, lue materiaalin kohdasta Liukuluvut eli desimaaliluvut missä vika on.
Anna ensimmäinen luku: 3 Anna toinen luku: 2 Jakolasku: 3 / 2 = 1.5
Ympyrän kehän pituus lasketaan kaavalla 2 * pii * säde
.
Tee ohjelma, joka kysyy käyttäjältä ympyrän säteen ja laskee sen perusteella ympyrän kehän pituuden.
Javasta löytyy valmis piin arvo, saat sen kirjoittamalla Math.PI
laskutoimitukseen.
Anna ympyrän säde: 20 Ympyrän kehä: 125.66370614359172
Tee ohjelma, joka kysyy käyttäjältä kaksi kokonaislukua ja tulostaa luvuista suuremman.
Vihje: kun kirjoitat NetBeans:iin Math. (eli Math ja perään piste), näet erinäisiä Javan valmiita matemaattisia laskutoimituksia, esim. Math.cos(10)
laskee luvun 10 kosinin. Kokeile, löydätkö Math:sta sopivan työkalun seuraavan ohjelman tekemiseen. Jos et löydä tai osaa tehdä tätä kohtaa, siirry heti eteenpäin. Tutustumme asiaan tarkemmin myöhemmässä vaiheessa.
Anna ensimmäinen luku: 20 Anna toinen luku: 14 Luvuista suurempi: 20
Tee ohjelma, joka kysyy kahden käyttäjän nimet ja iät. Tämän jälkeen ohjelma tulostaa henkilöiden ikien summan.
Kerro nimi: Matti Kerro ikä: 14 Kerro nimi: Arto Kerro ikä: 12 Matti ja Arto ovat yhteensä 26 vuotta vanhoja.
Tehtäväpohjaan on liitetty valmis komponentti Ohjain
jonka avulla on mahdollista ohjata pientä robottia.
Pääohjelma "importoi" eli ottaa komponentin käyttöönsä lisäämällä koodin yläosaan import robotti.Ohjain;
. Komennolla Ohjain.kaynnista();
robottiohjain käynnistää robotin, ja luo ikkunan, jossa robotin kulkemista voi seurata.
Robottia liikutetaan komennoilla Ohjain.ylos();
, Ohjain.oikealle();
, Ohjain.alas();
, ja Ohjain.vasemmalle();
. Seuraavassa on esimerkkiohjelma robottiohjaimen käytöstä siten, että robottia siirretään kaksi ruutua ylöspäin:
import java.util.Scanner; import robotti.Ohjain; public class Paaohjelma { public static void main(String[] args) throws Exception { Scanner lukija = new Scanner(System.in); // käynnistetään robotti Ohjain.kaynnista(); Ohjain.ylos(); Ohjain.ylos(); // sammutetaan robotti Ohjain.sammuta(); } }
Yllä oleva ohjelma päätyy seuraavaan tilanteeseen:
Kuten huomaat, robotti jättää liikkuessaan jäljen kohtiin, missä se on käynyt.
Tehtävänäsi on tehdä ohjelmarunkoon ohjelma, joka kuljettaa robottia siten, että lopputilanne on seuraavanlainen.
Yllä suuremman suorakulmion leveys on 7 askelta ja korkeus on 5 askelta, ja pienemmän suorakulmion leveys on 3 askelta, ja korkeus 2 askelta. Kun olet lähettänyt tehtävän tarkastettavaksi ja palautusautomaatti hyväksyy sen, voit muokata koodia ja tehdä vapaasti erilaisia kuvioita!
Tähän mennessä tekemämme ohjelmat ovat edenneet suoraviivaisesti käskystä toiseen, toimien jokaisella suorituskerralla samalla tavalla. Jotta ohjelman suoritus voisi haarautua erilaisille suorituspoluille käyttäjän esim. käyttäjän antaman syötteen perusteella, tarvitsemme käyttöömme valintakäskyn.
int luku = 11; if ( luku > 10 ) { System.out.println("Luku oli suurempi kuin 10"); }
Ehto ( luku > 10 )
muuntautuu totuusarvoksi true tai false. Valintakäsky if
käsittelee siis lopulta vain ja ainoastaan totuusarvoja. Yllä oleva ehtolause luetaan "jos luku on suurempi kuin 10".
Huomaa, että if
-lauseen perään ei tule puolipistettä, sillä lause ei lopu ehto-osan jälkeen.
Ehdon jälkeen avaava aaltosulku {
aloittaa lohkon (block), jonka sisältö suoritetaan jos ehto on tosi. Lohko loppuu sulkevaan aaltosulkuun }
. Lohko voi olla kuinka pitkä tahansa.
Vertailuoperaattoreita ovat seuraavat:
>
suurempi kuin>=
suurempi tai yhtäsuuri kuin<
pienempi kuin<=
pienempi tai yhtäsuuri kuin==
yhtäsuuri kuin!=
erisuuri kuinint 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"); }
Lohkon sisällä voi olla mitä tahansa koodia, myös toinen valintakäsky.
int x = 45; int luku = 55; if ( luku > 0 ) { System.out.println("Luku on positiivinen"); if ( luku>x ) { System.out.println(" ja suurempi kuin muuttujan x arvo"); System.out.println("muuttujan x arvohan on " + x); } }
Vertailuoperaattoreita voi käyttää myös ehtojen ulkopuolella. Tällöin ehdon totuusarvo asettuu totuusarvomuuttujaan.
int eka = 1; int toka = 3; boolean onkoSuurempi = eka > toka;
Yllä olevassa esimerkissä totuusarvomuuttuja onkoSuurempi
sisältää nyt totuusarvon false.
Totuusarvomuuttujaa voidaan käyttää ehtolauseessa ehtona.
int eka = 1; int toka = 3; boolean onkoPienempi = eka < toka; if ( onkoPienempi ) { System.out.println("1 on pienempi kuin 3!"); }
1 on pienempi kuin 3!
Huomaa, että if-komennon jälkeisen lohkon, eli {-merkkiä seuraavien rivien komentoja ei kirjoiteta samalle tasolle (eli yhtä "vasemmalle") kuin komentoa if, vaan ne sisennetään hieman -- maagiset neljä merkkiä -- oikealle. Neljä merkkiä saa myös tabulaattorimerkillä (q:n vasemmalla puolella oleva näppäin). Kun lohko sulkeutuu, eli tulee }-merkki, sisennys loppuu. }-merkki on samalla tasolla kuin if.
Väärin | Oikein |
---|---|
if (luku >= 10) { luku = 9; } |
if (luku >= 10) { luku = 9; } |
Sisennys on oleellinen seikka ohjelmien ymmärrettävyyden kannalta. Tällä kurssilla ja kaikkialla "oikeassa elämässä" edellytetään, että koodi sisennetään asiallisesti. NetBeans auttaa sisennyksessä. Ohjelman saa sisennettyä helposti painamalla yhtä aikaa shift, alt ja f.
Jos valinnan ehto on epätotta, eli totuusarvo on false, voidaan suorittaa toinen vaihtoehtoinen lohko koodia, tämä käy komennon else
avulla. Huomaa lähdekoodin sisennystyyli myös tässä.
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!
Huom! Komento else tulee samalle riville loppuvan aaltosulun kanssa. Jos et tee näin, tyylitarkastaja valittaa "Line xx: '}' should be on the same line."
Tee ohjelma, joka kysyy käyttäjältä kokonaisluvun ja kertoo, onko se positiivinen (eli suurempi kuin nolla).
Anna luku: 5 Luku on positiivinen.
Anna luku: -2 Luku ei ole positiivinen.
Onhan koodisi varmasti sisennetty oikein?
Kertaa materiaalista kohta Koodin sisennys. Kokeile mitä tapahtuu NetBeansissa kun painat yhtä aikaa shift, alt ja f! Sama toiminnallisuus eli automaattinen sisennys saadaan aikaan valitsemalla yläpalkista Source ja sen alta Format.Tee ohjelma, joka kysyy käyttäjän ikää ja kertoo, onko tämä täysi-ikäinen (eli 18-vuotias tai vanhempi).
Kuinka vanha olet? 12 Et ole vielä täysi-ikäinen!
Kuinka vanha olet? 32 Olet jo täysi-ikäinen!
Tee ohjelma, joka kysyy käyttäjältä luvun ja ilmoittaa, onko se parillinen vai pariton.
Anna luku: 2 Luku 2 on parillinen.
Anna luku: 7 Luku 7 on pariton.
Vihje: Luvun jakojäännös 2:lla kertoo, onko luku parillinen vai pariton. Jakojäännos taas saadaan %
-operaattorilla, tehtäväpohjassa on lisää ohjeita miten parittomuustarkastus hoituu jakojäännöksen avulla.
Jos valittavissa olevia vaihtoehtoja on enemmän kuin kaksi kannattaa käyttää else if
-komentoa, joka on kuten else
, mutta lisäehdolla. else if
tulee if
-ehdon jälkeen. else if
ehtoja 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("Aika paljon!"); }
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 "Aika paljon!"'.
Merkkijonoja, eli tekstejä, ei voi vertailla yhtäsuuri kuin (==) operaatiolla. Merkkijonojen vertailuun käytetään erillistä equals
-komentoa, joka liittyy aina verrattavaan merkkijonoon.
String teksti = "kurssi"; if ( teksti.equals("marsipaani") ) { System.out.println("Teksti-muuttujassa on teksti marsipaani."); } else { System.out.println("Teksti-muuttujassa ei ole tekstiä marsipaani."); }
Komento equals
liitetään aina siihen verrattavaan tekstimuuttujaan, "tekstimuuttuja piste equals teksti". Tekstimuuttujaa voidaan myös verrata toiseen tekstimuuttujaan.
String teksti = "kurssi"; String toinenTeksti = "pursi"; if ( teksti.equals(toinenTeksti) ) { System.out.println("Samat tekstit!"); } else { System.out.println("Ei samat tekstit!"); }
Merkkijonoja vertailtaessa on syytä varmistaa että verrattavalla tekstimuuttujalla on arvo. Jos muuttujalla ei ole arvoa, ohjelma tuottaa virheen NullPointerException, joka tarkoittaa ettei muuttujan arvoa ole asetettu tai se on tyhjä (null).
Tee ohjelma, joka kysyy käyttäjältä kaksi kokonaislukua ja tulostaa niistä suuremman. Jos luvut ovat yhtä suuret, ohjelma huomaa myös tämän.
Esimerkkitulostuksia:
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!
Tee ohjelma, joka ilmoittaa kurssiarvosanan seuraavan taulukon mukaisesti.
pistemäärä | arvosana |
---|---|
0–29 | hylätty |
30–34 | 1 |
35–39 | 2 |
40–44 | 3 |
45–49 | 4 |
50–60 | 5 |
Esimerkkitulostuksia:
Anna pisteet [0-60]: 37 Arvosana: 2
Anna pisteet [0-60]: 51 Arvosana: 5
Valinnan ehto voi olla myös monimutkaisempi, yksittäisten loogisten operaatioiden avulla koostettu ehto. Loogisia operaatioita ovat:
ehto1 && ehto2
lausekkeen arvo on tosi molemmat ehtoista ovat tosiaehto1 || ehto2
lausekkeen arvo on tosi jos jompi kumpi tai molemmat ehdoista tosia!ehto
lausekkeen arvo on tosi kun ehdon arvo on epätosiSeuraavassa yhdistetään &&
:lla eli ja-operaatiolla kaksi yksittäistä ehtoa, sillä halutaan tarkistaa, 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ää jomman kumman 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! :)
Seuraavassa käännetään !
:n eli negaatio-operaation avulla ehdon arvo päinvastaiseksi:
System.out.println("Eihän merkkijono ole 'maito'"); String merkkijono = "piimä"; if ( !(merkkijono.equals("maito")) ) { // tosi jos ehto merkkijono.equals("maito") on epätosi System.out.println("ei ollut!"); } else { System.out.println("oli") }
ei ollut!
Monimutkaisten ehtojen muodostamisessa tarvitaan usein sulkuja:
int luku = 99; if ( (luku > 0 && luku < 10) || luku > 100 ) { System.out.println("luku oli joko yhden ja yhdeksän väliltä tai yli sata"); } else { System.out.println("luku oli 0 tai pienempi tai väliltä 10-99"); }
luku oli 0 tai pienempi tai väliltä 10-99
Tee ohjelma, joka kysyy käyttäjän iän ja tarkistaa, että se on mahdollinen (ainakin 0 ja korkeintaan 120).
Kuinka vanha olet? 10 OK
Kuinka vanha olet? 55 OK
Kuinka vanha olet? -3 Mahdotonta!
Kuinka vanha olet? 150 Mahdotonta!
Tee ohjelma, joka tunnistaa seuraavat käyttäjät:
tunnus | salasana |
---|---|
aleksi | tappara |
elina | kissa |
Ohjelma näyttää käyttäjälle henkilökohtaisen viestin tai ilmoittaa, jos tunnus tai salasana on väärin.
Anna tunnus: aleksi Anna salasana: tappara Olet kirjautunut järjestelmään
Anna tunnus: elina Anna salasana: kissa Olet kirjautunut järjestelmään
Anna tunnus: aleksi Anna salasana: jokerit Virheellinen tunnus tai salasana!
HUOM: muista, että merkkijonoja ei voi vertailla ==-operaatiolla!
HUOM: Todellisuudessa kirjautumistoiminnallisuutta ei tule toteuttaa, eikä yleensä toteutetakkaan näin.
Vuosi on karkausvuosi, jos se on jaollinen 4:llä. Kuitenkin jos vuosi on jaollinen 100:lla, se on karkausvuosi vain silloin, kun se on jaollinen myös 400:lla.
Tee ohjelma, joka tarkistaa, onko vuosi karkausvuosi.
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.
Valintakomennon avulla saamme ohjelman toimintaan mukaan ehdollisuutta, eli esim. jos käyttäjätunnus ja salasana ovat oikein, päästetään käyttäjä kirjautumaan ohjelmaan ja muuten ei.
Ehdollisuuden lisäksi tarvitsemme toistoa: käyttäjätunnusta ja salasanaa pitää pystyä kysymään uudelleen niin kauan kunnes oikea käyttäjätunnus/salasana-pari on annettu.
Yksinkertaisin toiston muoto on ikuinen toisto. Seuraava ohjelma tulostaa merkkijonoa osaan ohjelmoida! ikuisesti eli "äärettömän monta kertaa":
while ( true ) { System.out.println("osaan ohjelmoida!"); }
Komento while( true )
saa sen aikaan, että siihen liittyvää lohkoa, eli {}
:lla ympäröityjä komentoja suoritetaan äärettömän monta kertaa.
Ikuinen toisto ei yleensä ole se mitä halutaan. Toisto voidaan keskeyttää esim. komennolla break
.
while ( true ) { System.out.println("osaan ohjelmoida!"); System.out.print("jatketaanko (ei lopettaa)? "); String komento = lukija.nextLine(); if ( komento.equals("ei") ) { break; } } System.out.println("kiitos ja kuulemiin.");
Nyt 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ä vastaa ei, suoritetaan komento break
jonka ansiosta toisto lopetetaan ja suoritetaan komento joka tulostaa kiitos ja kuulemiin.
osaan ohjelmoida! jatketaanko (ei lopettaa)? joo osaan ohjelmoida! jatketaanko (ei lopettaa)? jawohl osaan ohjelmoida! jatketaanko (ei lopettaa)? ei kiitos ja kuulemiin.
Toiston sisällä voi tehdä erilaisia asioita. Seuraavassa yksinkertainen laskin. Laskin kysyy käyttäjältä komentoa. Komennossa lopetus suoritetaan break
ja toisto loppuu. Tämän jälkeen kysytään kahta lukua. Jos komento oli summa lasketaan lukujen summa ja tulostetaan se. Jos komento oli erotus toimitaan vastaavasti. Muussa tapauksessa ilmoitetaan että komento on tuntematon.
System.out.println("tervetuloa käyttämään laskinta"); while ( true ) { System.out.print("anna komento (summa, erotus, lopetus): "); String komento = lukija.nextLine(); if ( komento.equals("lopetus") ) { break; } System.out.print("anna luvut "); int eka = Integer.parseInt(lukija.nextLine()); int toka = Integer.parseInt(lukija.nextLine()); if ( komento.equals("summa") ) { int summa = eka + toka; System.out.println( "lukujen summa " + summa ); } else if ( komento.equals("erotus") ) { int erotus = eka - toka; System.out.println( "lukujen erotus " + erotus ); } else { System.out.println( "tuntematon komento" ); } } System.out.println("kiitos ja kuulemiin.");
Screencast joka näyttää miten ohjelma syntyy:
Tässä tehtävässä luodaan ohjelma joka kyselee käyttäjältä salasanaa. Jos salasana menee oikein, nähdään salainen viesti.
Anna salasana: nauris Väärin! Anna salasana: lanttu Väärin! Anna salasana: porkkana Oikein! Salaisuus on: znvavbfgv grugl!
Toteutetaan ohjelma kolmessa askeleessa.
Testipalvelimelta tulevaan ohjelmarunkoon on määritelty muuttuja String salasana
, jolle on asetettu arvoksi porkkana
-- älä muuta tätä salasanaa. Toteuta lisätoiminnallisuus, jossa ohjelma kysyy käyttäjältä salasanaa ja vertailee sitä muuttujassa salasana
olevaan arvoon. Muista mitä erityistä merkkijonojen vertailussa on!
Anna salasana: nauris Väärin!
Anna salasana: porkkana Oikein!
Anna salasana: bataatti Väärin!
Muokkaa ohjelmaa siten, että se kysyy salasanaa kunnes käyttäjä syöttää oikean salasanan. Toteuta salasanan jatkuva kysyminen while-true
-toistolausekkeen avulla. Toistolausekkeesta pääsee pois, jos ja vain jos käyttäjän syöttämä salasana on sama kuin muuttujassa salasana
oleva arvo.
Anna salasana: nauris Väärin! Anna salasana: lanttu Väärin! Anna salasana: porkkana Oikein!
Lisää ohjelmaan oma salainen viestisi joka näytetään kun käyttäjä kirjoittaa salasanan oikein. Se voi olla mitä tahansa!
Anna salasana: nauris Väärin! Anna salasana: lanttu Väärin! Anna salasana: porkkana Oikein! Salaisuus on: znvavbfgv grugl!
Ylläoleva salaisuus on salattu käyttäen Rot13-algoritmia. Toteutamme myöhemmin tällä kurssilla oman salausohjelman.
Saat tehtäväpohjan mukana komponentin nimeltään Kuvaaja
. Kuvaaja
piirtää
sille annetuista luvuista kuvaajan. Lukuja annetaan kuvaajalle näin:
Kuvaaja.lisaaNumero(13.0);
Teemme ohjelman, joka piirtää kuvaajan sille annetuista päivittäisistä lämpötiloista.
Tee ohjelma, joka kysyy käyttäjältä liukulukuja (double
) ja lisää ne kuvaajaan. Käytä jälleen while-true
-rakennetta.
Huom:double
-luku luetaan seuraavasti double luku = Double.parseDouble( lukija.nextLine() );
Huom2: ohjelmasi toimii "ikuisessa" silmukassa eli on tarkoitus että sen suoritus ei pääty koskaan. Saat ohjelmasi pysähtymään painamalla NetBeansin konsoli-ikkunan oikeassa laidassa olevaa punaista neliöä.
HUOM3: Tee kaikki muutokset tiedostoon Lampotiloja.java
. Älä muokkaa tiedostoa Kuvaaja.java
Paranna edellistä ohjelmaasi niin, että lämpötilat jotka ovat alle -30 tai yli 40 jätetään lisäämättä.
Robottimme on kehittynyt, sillä on silmät ja suunta! Huraa!
Tässä tehtävässä ohjaamme robottia, jonka tehtävänä on työntää varastossa oleva laatikko rahtialueelle. Kuvassa robotti on musta neliö jolla on silmät, laatikko harmaa, ja rahtialue turkoosi.
Uusi robottimme ei enää kuuntele käskyjä "ylös", "alas", "vasemmalle" ja "oikealle", vaan se kulkee siihen suuntaan, mihin se osoittaa. Robottia voi kääntää komennoilla Ohjain.vasen();
ja Ohjain.oikea();
, jotka kääntävät robottia vastapäivään ja myötäpäivään. Robotin liikuttaminen tapahtuu komennoilla Ohjain.liiku();
, joka siirtää robottia yhden askeleen robotin osoittamaan suuntaan, ja Ohjain.liikuMonta(int montako);
, joka liikuttaa robottia annetun määrän askelia osoitettuun suuntaan.
Robotin alkutilanteessa se suuntaa katseensa oikealle. Alla olevassa tilanteessa robottia on käännetty vasemmalle, jolloin sen katse suuntaa ylös, ja sitä on komennettu liikkumaan kolme kertaa.
Tehtävä on jaettu useampaan osaan, joissa ensimmäisessä toteutetaan manuaalinen ohjaus robotille, ja seuraavissa kehitämme automaattista ohjausta.
Tässä tehtävässä tavoitteena on rakentaa robotille manuaalinen ohjaus. Rakenna ohjelma samalla tavalla kuin edellä oleva laskin-esimerkki. Ohjelman tulee seurata seuraavia komentoja:
Ohjain.sammuta();
) ja poistuu ohjelmasta.Ohjain.vasen();
).Ohjain.oikea();
).Ohjain.liiku();
).Ohjain.liikuMonta(int montako);
).Huom! Komento Ohjain.sammuta()
sammuttaa vain robottiohjaimen, ei ohjelmaasi jonka kautta robottiohjainta käytetään. Avainsanasta break saattaa olla tässä hyötyä..
Toteuta ohjelma siten, että ohjain suorittaa käyttäjän pyytämät komennot. Alla on esimerkki annetuista komennoista sekä kuva lopputilasta.
komento (sammuta, vasen, oikea, liiku, liikuMonta): liiku komento (sammuta, vasen, oikea, liiku, liikuMonta): vasen komento (sammuta, vasen, oikea, liiku, liikuMonta): liiku komento (sammuta, vasen, oikea, liiku, liikuMonta): liiku komento (sammuta, vasen, oikea, liiku, liikuMonta): oikea komento (sammuta, vasen, oikea, liiku, liikuMonta): liikuMonta Kuinka monta askelta: 3
Huom! Voit palauttaa tehtävän jo tässä välissä vaikka kaikki tehtävän osa-alueet eivät vielä menisikään läpi!
Lisää tekstikäyttöliittymään komento "viereen", joka siirtää robotin laatikon viereen sen vasemmalle puolelle. Ratkaisua ohjelmoidessa voit olettaa, että robotti lähtee liikkeelle aina sen alkusijainnista, se katsoo aluksi aina samaan suuntaan, ja että rahtialue on aina samassa kohdassa.
Ohjaimeen on lisätty seuraavat komennot, joiden avulla saat käyttöösi robotin, laatikon ja rahtialueen sijainnin. Voit käyttää niitä robotin tarvitsemien siirtymien laskemiseen.
// kertoo robotin x- ja y-koordinaatit int robottiX = Ohjain.robottiX(); int robottiY = Ohjain.robottiY(); // kertoo laatikon x- ja y-koordinaatit int laatikkoX = Ohjain.laatikkoX(); int laatikkoY = Ohjain.laatikkoY(); // kertoo rahtialueen x- ja y-koordinaatit int tavoiteX = Ohjain.tavoiteX(); int tavoiteY = Ohjain.tavoiteY();
Yllä komentojen lisäksi käytössä on komento Ohjain.asetaLaatikkoSatunnaisesti();
, joka asettaa laatikon satunnaisesti pelialueelle, kuitenkin siten, että se on aina robotin oikealle yläpuolella, ja rahtialueen vasemmalla yläpuolella. Kutsu sitä ennen käynnistystä seuraavasti:
public class Paaohjelma { public static void main(String[] args) { Scanner lukija = new Scanner(System.in); Ohjain.asetaLaatikkoSatunnaisesti(); Ohjain.kaynnista(); // toteuta ohjelma tänne // oma toteutuksesi, joka saattaa alkaa muodossa while (true) { // ...
komento (sammuta, vasen, oikea, liiku, liikuMonta, viereen): viereen
Vinkki! Kannattanee hahmotella paperilla miten robotin siirtyminen ja liike riippuu laatikon sijainnista.
Lisää vielä käyttöliittymään komento "ratkaise", joka käskee robottia työntämään laatikon rahtialueelle. Kuten edellisessäkin osassa, voit olettaa että laatikko on aina robotin oikealla yläpuolella ja rahtialueen vasemmalla yläpuolella, robotti aloittaa liikkumisen aina samasta ruudusta, katsoo aluksi samaan suuntaan, ja että rahtialue on aina samassa ruudussa. Komennon "ratkaise" tulee toimia myös silloin, kun se annetaan komennon "viereen" jälkeen.
komento (sammuta, vasen, oikea, liiku, liikuMonta, viereen, ratkaise): ratkaise
Komennon "ratkaise" tulee toimia vaikka robotti ei olisi laatikon vieressä.