Luokkakirjastot. esiintymämetodien käytöstä:

Transkriptio

1 Luokkakirjastot Esimerkkejä Jokainen olio on jotain tyyppiä ja ko. tyyppistä oliota voidaan käsitellä ko. luokan metodeilla Merkkijonojen käsittely: String, StringBuffer, StringBuilder, StringTokenizer,.. Matemaattiset funktiot ja vakiot (metodikirjasto): Math perustyyppien kuoriluokat: Integer, Double, satunnaislukujen generointi: Random dynaamiset geneeriset listat: Vector<E>, ArrayList<E>, LinkedList<E>, missä E voi olla mikä tahansa viittaustyyppi pino: Stack<E>, myös luokka LinkedList sisältää pino-operaatiot Arrays ja Collections: staattisia metodeja (esim. lajittelu) hajautustaulu HashMap<K,V>, joukko HashSet<E> (ei vaadita) Luokkakirjastoissa luokkien kuvauksessa on annettu luokan tietokenttien (Field Summary), konstruktorien (Constuctor Summary) ja metodien (Method Summary) kuvaukset. Tietokenttien ja metodien kuvauksessa voi olla määre static, jolloin se on ns. luokkamuuttuja, luokkavakio tai luokkametodi. Näitä käytetään muodossa <luokan nimi>.<kentän nimi tai metodi kutsu>. Jos metodin kuvauksessa ei ole määrettä static, niin kyseessä on ns. esiintymä (tai ilmentymä- tai instanssi-) metodi, joita käytetään muodossa <olio>.<metodin kutsu>. Luokkien String, Integer ja Double oliot eivät ole mutatoituvia, mutta luokkien StringBuffer ja StringBuilder ovat. esiintymämetodien käytöstä: String st = new String( abc ); // tai: String st = abc ; ero? String mjono = st.substring(2,3); mjono = st.replace( a, b ); // StringBuffer/StringBuilder?? mjono = mjono.replace( bb, xx ); StringBuffer sb = new StringBuffer(mjono); // ero Stringiin? String s = sb.substring(2, 3); // ero ed. substring nähden! StringBuffer sbuusi = sb.append("y"); // mitä tapahtuu sb:lle? sb.append(sb); Random r = new Random(); int k = 1+ r.nextint(9); luokkametodien käytöstä: String s = String.valueOf(2.5); double d = Double.parseDouble( 33 ); double x = -2.5; double y = Math.abs(x); double z = Math.random(); Kiinnitä huomiota siihen onko metodi funktio vai proseduuri (tässä tulee myös muistaa, että Javassa funktiota voidaan käyttää lauseen tavoin) mitkä ovat metodin parametrit onko metodissa määre static, joka määrää sen onko kyseessä luokka- vai esiintymämetodi ja siis sen miten sitä käytetään (kutsutaan) 1 2

2 ADT lista 1) Kiinteän mittainen lista kannattaa toteuttaa staattisella taulukolla: esittely on muotoa: <tyyppi> [ ] <muuttujan nimi> esim. int [ ] v; char [ ] c; String [ ] s; Tili [ ] t; taulukon koko (pituus) ilmoitetaan aina luonnin (new) yhteydessä ja sitä ei saa enää sen jälkeen muuttaa. Kuitenkin taulukon komponenttien sisältöä voidaan muuttaa. taulukot ovat olioita ja esitellyt oliot luodaan käyttäen new:tä: v = new int [k]; c = new char [4]; s = new String [n+1]; t = new Tili [n]; usein esittely ja luonti yhdistetään: int [ ] v = new int [k]; char [ ] c = new char [4]; String [ ] s = new String [n+1]; (alkiot viittauksia olioihin) Tili [ ] t = new Tili [n]; (alkiot viittauksia olioihin) taulukon komponenttiin viitataan indeksillä, joka alkaa nollasta: esim. v[0] ja t[k]. Huom. tämä on poikkeava tapa verrattuna muihin olioihin, joita käsitellään aina metodien kautta (paitsi String-oliot, joita voidaan käsitellä ja luoda Javassa kryptisesti). Esim. lista.get(k) käydään läpi toistorakenteella (usein for), jossa taulukon indeksi toimii silmukkalaskurina o indeksiä ei tarvita, kun käytetään for-each -rakennetta: esim. for (int x:taulu) }, kun taulu viittaa int-taulukkoon tai voimme määritellä myös iteraattorin 2) Vaihtelevan mittainen lista kannattaa toteuttaa dynaamisilla rakenteilla (oliokokoelmat) Vector, ArrayList ja LinkedList, joiden alkiot ovat tyyppiä Object (kaikkien oliotyyppien ylityyppi) Java 5.0:sta lähtien kannattaa käyttää niiden geneerisiä vastineita Vector<E>, ArrayList<E> ja LinkedList<E>, joiden alkiot ovat tyyppiä E, joka voi olla mikä tahansa oliotyyppi. Siis tyyppi kiinnitetään esittelyn yhteydessä. Rakenteeseen voidaan tallentaa myös E:n alityypin alkioita. Näillä kaikilla ovat metodit get(i) ja add(e). Vector ja ArrayList: toteutettu staattisella taulukolla. LinkedList: toteutettu linkitettynä rakenteena (ks. TTP I) Tehtävä: Olkoon v dynaaminen lista ArrayList<Integer>. Kirjoita lause, joka poistaa v:n viimeisen alkion. Mitä muuttuu jos alkiotyyppi muuttuu? Entä jos tarkastelemme rakenteita Vector ja LinkedList? Entä jos pitää poistaa taulukon viimeinen komponentti? Esimerkki. Luetaan int-lukuja dynaamiseen listaan. Syöttö lopetetaan, kun ei anneta int-luvun esitystä (esim. tekstiä). Tulostetaan kuinka monta prosenttia listan alkioista on suurempia kuin annettu rajaluku. import java.util.*; public class SuurempiaVector public static void main (String[] args) Vector<Integer> lista = luelista(); if (lista.size()>0) System.out.println(suurempiaKuin(lista,6)); } 3 4

3 /** Luetaan lukuja Vector-rakenteeseen, joka palautetaan. * Kun halutaan lopettaa syöttö, annetaan tekstiä luvun sijasta. */ public static Vector<Integer> luelista() Scanner scan = new Scanner(System.in); // luodaan tyhjä vektori Vector<Integer> v = new Vector<Integer>(); System.out.println("Anna luku (lopuksi tekstiä)"); while (scan.hasnextint()) int luku = scan.nextint(); v.add(new Integer(luku)); // lisäys listan v loppuun System.out.println("Anna seuraava luku "); } // while scan.nextline(); return v; } // luelista Oletetaan, että käyttäjä syöttää luvut 12, 21, 9 ja x. Muistia voidaan havainnollistaa seuraavasti: (a) tilanne, kun 12 on lisätty v:n loppuun, (b) 21 ja (c) 9 on lisätty v:n loppuun. v 12 v v /** Funktio palauttaa kuinka monta prosenttia Integer-olioita * sisältävän listan v alkioista on suurempia kuin parametrina * annettu rajaluku raja. Täydennä. * Alkuehto: lista ei saa olla tyhjä. */ public static double suurempiakuin(vector<integer> v, int raja) int maara = 0; for (int k =0; ; ) if ( ) maara++; } // for return ((double)maara/v.size())*100.0; } // metodi suurempiakuin } // luokan loppu Tehtävä: Muunna eo. hyödyntämään Java 5.0:n for-each rakennetta. Mitä muuttuu, jos hyödynnetään automaattista tyypin muunnosta Integer <-> int? Mitä muuttuu jos käytämme rakennetta ArrayList tai LinkedList? Muutetaan ohjelmaa siten, että lukeminen lopetetaan kun annetaan x ja kaikki muut ei-int-esitykset tulkitaan virheiksi, jolloin luetaan luku uudestaan. Tällöin kannattaa lukea rivi aina merkkijonomuuttujaan, joka muutetaan int-luvuksi parseintmetodilla. Tämä yritys 'kaatuu', jos syötteenä ei anneta kokonaislukua. Kaatuminen voidaan estää käyttämällä Javan poikkeuksia ja try-catch lausetta seuraavalla tavalla: (a) (b) (c) 5 6

4 /** Luetaan lukuja näppäimistöltä listaan Vector, joka palautetaan. * Kun halutaan lopettaa, näppäillään x */ public static Vector<Integer> luelista() Scanner scan = new Scanner(System.in); // luodaan tyhjä vektori Vector<Integer> v = new Vector<Integer>(); boolean luetaan = true; while (luetaan) System.out.println("\nAnna seuraava luku (lopuksi x)"); String rivi = scan.nextline(); if (rivi.equals("x")) luetaan = false; // lopeta while-silmukka else try int luku=integer.parseint(rivi); } // try catch (NumberFormatException e) System.out.println("Et antanut kokonaislukua etkä x:ää\n"); continue; // aloita while-silmukkaa uudestaan } // catch } // else } // while return v; } // luelista // nyt muuttujassa rivi on kokonaisluvun esitys v.add(new Integer(rivi)); // käykö v.add(rivi)? Voiko kirjoittaa v.add(luku); Tehtävät 6 ja 7 (s. 88). Tästä puuttuvat ulkoiset kuvaukset. Tyypin käsite on tässä erittäin tärkeä ja mitä erityyppisille alkiolle voi tehdä. Alkuehdot? Täydennä. import java.util.*; public class MerkkijonoTaulukoksiJaPainvastoin public static void main (String[ ] args) int[] v = merkkijonotaulukoksi(" "); for (int k = 0; k < v.length; k++) System.out.println(v[k]); String s = taulukkomerkkijonoksi(v); System.out.println(s); } // main public static int[] merkkijonotaulukoksi(string syöte) StringTokenizer stok = new StringTokenizer(syöte); int maara = stok.counttokens(); int[] v = new int [maara]; for (int k = 0; k < maara; k++) v[k] = ; return v; } // merkkijonotaulukoksi public static String taulukkomerkkijonoksi(int[] v) String tulos =""; for (int k = 0; k < v.length; k++) tulos = ; return tulos.trim(); } // taulukkomerkkijonoksi } // class 7 8

5 String ei ole mutatoituva, joten katenaation + (eli liitä loppuun) yhteydessä luodaan aina uusi olio (ja roskaa syntyy). Sen vuoksi usein käytetäänkin luokkaa StringBuffer, jonka alkiot ovat mutatoituvia. Alla on tällainen ratkaisu (täydennä): public static String taulukkomerkkijonoksibuffer(int[] v) StringBuffer tulos = new StringBuffer(""); for (int k = 0; k < v.length; k++) merkkijonotaulukoksi käyttämällä luokan String metodia split menee näin näppärästi: public static int[] merkkijonotaulukoksi(string syöte) String[] stok = syöte.split(" +"); int[] v = new int[stok.length]; for (int k =0; k< stok.length; k++) v[k] = Integer.parseInt(stok[k]); return v; } } return tulos.tostring().trim(); Split vaatii argumentikseen ns. säännöllisen lausekkeen, jonka yleinen muoto kuvataan luokkakirjastossa metodin split yhteydessä. Edellä append on luokan StringBuffer esiintymämetodi (muutosmetodi), jolloin sen kutsu kohdistetaan olioon. Tällöin käsitellään koko ajan samaa olioita (johon muuttuja tulos viittaa), jonka sisältö muuttuu (mutatoituu). Huomaa, että append on 'raskaasti' ylikuormitettu ja sillä voi siis olla parametrina myös luku, jolloin metodissa append ko. luku muutetaan ensin merkkijonotyyppiseksi ja sen jälkeen suoritetaan katenointi. Lopuksi tulos tulee muuntaa vielä String-tyyppiseksi luokan StringBuffer metodilla tostring. trim- poistaa alku- ja lopputyhjät. Splitin argumenttina välilyönnin perässä oleva + tarkoittaa: yksi tai useampi. Eli tässä tapauksessa jako tehdään aina kun merkkijonossa on yksi tai useampi välilyönti peräkkäin ja nämä välilyönnit eivät tule mukaan. Miten metodia merkkijonotaulukoksi voi kutsua jostain muusta luokasta, joka sijaitsee samassa hakemistossa? Entä jos haluammekin merkkijonosta dynaamisen listan LinkedList <Integer>? Onko jossain luokassa metodeja, joilla vaaditut muunnokset voitaisiin suorittaa suoraan? 9 10

6 Luokista Javassa luokan avulla tehdään mm.: 1. uusi tietotyyppi, jonka yhteydessä määritellään karakterisoivat tiedot (tietokentät eli attribuutit) ja metodit, joilla luokan mukaisia alkioita (olioita) tulee käsitellä. 2. metodi- eli aliohjelmakirjasto 3. pääohjelma (sisältää main-metodin) Kohdan 2 luokista ei luoda esiintymiä (olioita) ja niiden metodit ja tietokentät (luokan alussa) ovat määreeltään static. Seuraavassa käsitellään vain Kohdan 1 mukaisia luokkia, jotka koostuvat: tiedoista, joilla luokan mukaiset alkiot karakterisoidaan, näitä sanotaan luokan tietokentiksi tai luokan muuttujiksi (luokan alussa olevat muuttujien ja vakioiden esittelyt) konstruktoreista, jolla ko. luokan mukaisen olion tietokentät alustetaan olion luonnin yhteydessä. Konstruktorin nimi=luokan nimi ja sillä ei ole tulostyyppiä lainkaan ja sillä on yleensä parametri kutakin luokan tietokenttää kohti. metodeista, joilla ko. luokan mukaisia alkioita käsitellään public class <luokan nimi> <luokan tietokentät> <luokan konstruktorit> <luokan muut metodit> } Luokat ja niiden havaitseminen (ei ole oppaassa) Luokkia löydetään usein etsimällä sovellusalueen kuvauksesta substantiiveja, joiden voidaan ajatella olevan olioita, joilla on identiteetti, tietty tila ja käyttäytyminen. Luokka on tietotyyppi, joka on staattinen kuvaus ajonaikana luotavista olioista. Luokan tietokentät ovat luokan karakterisoivia tietoja, jotka ovat yleensä luokkaan liittyviä substantiiveja tai adjektiiveja. Luokan metodit löydetään etsimällä sovellusalueeseen liittyviä verbejä. Metodit sijoitetaan lähinnä sopivimpaan luokkaan. Sovelluskohde mallinnetaan luokkien ja niiden välisten rakenteellisten suhteiden kautta (perintä!). Samasta asiasta voi olla eri näkökulmia (esim. auto: käyttäjä vs. korjaaja). Laajaan ohjelmakokonaisuuteen kuuluu useita luokkia, joiden tunnistaminen ja luokkien välisten suhteiden määrääminen on usein vaikeata ja joudutaan tekemään usein uudestaan. Tärkeänä motivaationa on myös luokkien ja metodien uudelleenkäyttö: samaa ohjelmakoodin pätkää ei tulisi kirjoittaa moneen kertaan. Seuraavalla jaksolla TJM tarkastellaan oliopohjaista mallinnusta, jossa käytetään UML-mallinnuskieltä

7 Tunnuksien nimeämiskäytäntö luokat nimetään yleisesti substantiiveilla ja niiden nimen ensimmäinen kirjain kirjoitetaan isolla kirjaimella kenttien nimet ovat yleensä substantiiveja (totuusarvot voivat olla myös adjektiiveja tai kysymyksiä) ja niiden ensimmäinen kirjain kirjoitetaan pienellä, mutta vakioiden nimet kirjoitetaan kokonaan isoilla metodien nimet ovat yleensä verbimuotoisia, josta näkyy kohdekenttä ja ne aloitetaan pienellä kirjaimella: getnimi(), setnimi (String uusinimi) jos tunnus koostuu useammasta sanasta, toisesta sanasta eteenpäin kaikki sanat kirjoitetaan isolla alkukirjaimella yhteen ilman alaviivoja tunnuksien tulee olla kuvaavia ja ytimekkäitä Olio-ohjelmointiin liittyvät tärkeät käsitteet: Luokan tietokenttä voi olla: luokkamuuttuja, luokkavakio, esiintymämuuttuja Luokan metodi voi olla: luokkametodi, esiintymämetodi, konstruktori (alustaja) Näiden osoittamiseen ohjelmointikielessä on tietty syntaksi! Luokan tietokentät: luokkamuuttuja/esiintymämuuttuja: Jos tietokentän arvo voi olla eri luokan eri oliolla, niin tällaista muuttujaa kutsutaan esiintymämuuttujaksi (oliokohtainen) Luokalla voi olla tietokenttä, joiden arvo on yhteinen kaikilla luokan olioilla. Tällaista kutsutaan luokkamuuttujaksi (se on siis luokkakohtainen). Luokan metodit: luokkametodi/esiintymämetodi: Tyypillisesti luokassa määritellään metodeja, joilla voidaan käsitellä ko. luokan mukaisia olioita kohdistamalla ko. metodin kutsu ko. luokan olioon. Tällaisia metodeja kutsutaan esiintymämetodeiksi, koska niitä voidaan kohdistaa vain luokan mukaiseen esiintymään, olioon. Joskus taas halutaan luokassa määritellä metodi, jota voidaan käyttää ei-olio-ohjelmoinnin tavoin, jolloin metodi ei vaadi luokan esiintymää eikä sitä kohdisteta olioon. Tällaista metodia kutsutaan luokkametodiksi. Miten tämä ilmaistaan Javassa: jos kyseessä on luokkamuuttuja tai metodi, kirjoitetaan sen määreeksi static. Jos määre static puuttuu, tarkoittaa se että kyseessä on esiintymämuuttuja tai metodi. Siis: aina kun otamme luokkaan mukaan tietokentän tai metodin, niin meidän tulee miettiä mihin yllä olevista ryhmistä se kuuluu eli sitä kirjoitetaanko sen määreeksi static vai eikö

8 Näkyvyysmääreet Javassa Tietokentälle ja metodille asetetaan yleensä näkyvyysmääre: public/private/protected/ joka määrää ko. muuttujan tai metodin näkyvyyden ja käytettävyyden muissa luokissa. Näkyvyysalueena on ns. pakkaus eli paketti (package). Jos sitä ei ole luokkaan määritelty, niin se on hakemisto, jossa ko. luokka on. public: julkinen, käyttö sallittu kaikissa luokissa (milloin import?) private: käyttö sallittu vain luokan itsensä sisällä protected: voi käyttää aliluokissa sekä luokissa, jotka ovat samassa pakkauksessa määre puuttuu: voidaan käyttää niissä luokissa, jotka ovat samassa pakkauksessa. Vaatimus tällä kurssilla: tietokentät varustetaan määreellä private metodit public Huom. Luokan kirjoittaja määrää sen, mitkä tiedot näkyvät ulospäin, ja mitä luokan mukaisille olioille saa tehdä: mitä tietoja voi katsoa (havainnointimetodit) ja mitä tietoja saa muuttaa (muutosmetodit) ja minkälaiset muutokset ovat sallittuja olion pitää olla eheässä tilassa eli tietokentillä pitää olla aina lailliset arvot. Tämä pitää huomioida kirjoitettaessa muutosmetodeja. Kyseessä on siis mallinnuksen lisäksi systeemin suunnitteluperiaate. Esim. luokassa Tili on estetty se, että luokan käyttäjä (asiakas) voisi asettaa saldoksi tietyn summan (vain nosto ja talletus on sallittu). Metodien looginen ryhmittely luokassa Esiintymämetodit jaetaan vielä toiminnallisuuden mukaan Konstruktorit (alustajat) Havainnointimetodeihin (olion tila ei muutu) Muutosmetodeihin (olion tila muuttuu) Muut metodit (yleensä apumetodien luonteisia) Tätä ei ilmaista millään määreellä itse ohjelmakoodissa, vaan tämä on looginen jako, joka ilmoitetaan esittämällä metodit ryhmittäin ja varustamalla ryhmät kommenteilla

9 Olioiden luonti Luokan olion esiintymä eli instanssi luodaan käyttäen newlauseketta, jossa on aina mukana konstruktorin kutsu: new <konstruktorin nimi> ( <mahd. parametrit>) Konstruktorin nimi = sen luokan nimi, jossa konstruktori on määritelty Lausekkeen arvo on viittaus olioon, joka asetetaan yleensä muuttujan arvoksi Konstruktoria voi kutsua vain new:n kanssa ja kutsun jälkeen tulisi tietokentillä olla aina haluttu arvo. Näin ollen konstruktori ei luo oliota, vaan alustaa olion tietyt (useimmiten kaikki) tietokentät. Nämä arvot ovat konstruktorin parametreja. Luonnin suorittaa new. Alustamattomilla tietokentillä on Javassa oletusarvot. Tyypillisesti konstruktoreita kirjoitetaan useita (ylikuormitus). Ellemme ole kirjoittaneet luokkaan yhtään kostruktoria, käytössä on silti parametriton oletuskonstruktori, joka asettaa tietokentille oletusarvot (konstruktoria ei siis tarvitse kirjoittaa luokaan lainkaan, ellei tietokentille haluta antaa arvoja). JavaBeans suosittelee että tällainen parametriton konstruktori kirjoitetaan aina luokkaan. Miksiköhän? Kuinka luokan tietokenttiin ja metodeihin voidaan viitata (anna esimerkit): viittaus sen luokan sisällä, jossa tietokenttä tai metodi esitellään: ko. luokan metodeissa voidaan kaikkiin luokan tietokenttiin ja metodeihin viitata muodossa <olio>.<metodin kutsu tai tietokentän nimi> Jos tarkastellaan kohdeolioita (kuten yleensä) tulee <olio>:n tilalla olla this tai sen voi jättää pois. luokan tietokenttien ja metodien käyttö muissa luokissa: 1. jos näkyvyys on private: ei voi viitata suoraan. Tietokenttiä voidaan käsitellä luokassa olevien julkisten (public) havainnointi- ja muutosmetodien kautta 2. jos näkyvyys on public (eli kyseessä on julkinen tietokenttä tai metodi): jos määreenä ei ole static, niin kyseessä on julkinen esiintymämuuttuja tai esiintymämetodi (kohdistetaan olioon): viitataan muodossa <olio>.<metodin kutsu tai tietokentän nimi> Julkisten tietokenttien käyttö ei noudata kapselointiperiaatetta. jos määreenä on static, niin kyseessä on julkinen luokkamuuttuja (tai vakio) tai luokkametodi, jonka kutsu kohdistetaan luokkaan: viitataan muodossa <luokan nimi, jossa metodi tai tietokenttä on määritelty>. <metodin kutsu tai tietokentän nimi> 17 18

10 Käydään läpi opiskeluoppaan luokka Tili ja siihen liittyvät esimerkit. Luokat Pankki ja PankkiKoe Tilit tallennetaan ArrayList<Tili>-rakenteeseen, jonka jokaisen komponentin arvo on luokan Tili olio (tarkemmin: viittaus Tiliolioon) Kun pankki luodaan (perustetaan), pankilla ei ole tilejä lainkaan. Luokkaan Pankki tehdään metodi lisäätili, jolla voidaan lisätä parametrina annettu Tili-olio ArrayList-rakenteen tilit loppuun. Luokalla PankkiKoe voidaan testata luokkien Tili ja Pankki toimivuutta. Käydään läpi opiskeluoppaan luokka Pankki. Mitä metodeja voisi vielä olla? Huomaa, että luetaan aina rivi kerrallaan merkkijonomuuttujaan ja tehdään tarvittaessa tyypin muunnos. Tämä on hyvä tapa. Miksi? Metodi kaatuu, jos tieto syötetään väärin. Mikä pelastukseksi? Miksi luokassa on metodi lisäätili, vaikka se sisältää vain yhden lauseen? Suurinta saldoa haettaessa hyvä alkuarvo on 0.0 (tai neg.), mutta tämä voidaan ratkaista myös toisin. Miten? Käydään läpi opiskeluoppaan luokka PankkiKoe ja piirretään kuva luokan Pankki oliosta pankki Luokassa PankkiKoe ei saa näkyä se millaiseen tietorakenteeseen tilitiedot on tallennettu (tässä ArrayList <Tili>). Tällöin luokassa Pankki voidaan esim. muuttaa tilitietojen tallennusrakennetta ja luokan Pankki käyttäjän ei tarvitse tietää siitä mitään. Olio-ohjelmoinnin periaatteita: s. 71 Perintä: katsotaan Viikon 10 teksti. Käydään läpi opiskeluoppaan s luokka ShekkiTili, jossa korkoprosentti on aina 0.0, ja siihen liittyvät esimerkit. Jos aikaa jää: Tehdään yhdessä taululle s. 88 tehtävä 4 ja ehkä myös 3 Rajapintaluokka: s Metodi compareto luokkaan Tili? 19 20

11 21 22

12 23 24