9789144094427 by Smakprov Media AB

Programmeringsprinciper i Java är en lärobok i grundläggande programmering och objektorienterad programmering. Det finns tre parallella spår genom boken: lättförståeliga konceptbeskrivningar, exempelprogram med sammanfattningar och förklaringar samt övningar som lyfter fram typiska programmeringssituationer. Genom att ett och samma ämne belyses på tre olika sätt underlättas och fördjupas inlärning och förståelse.

Java

Programmeringsprinciper i

Java

Den första delen av boken omfattar grundläggande programmeringskunskaper. Datalagring och databearbetning, logik, ett programs organisation och klassbibliotek behandlas. En introduktion till algoritmer tar upp en central plats i boken. Avsnittet om algoritmer visar vägen från ett problem till dess lösning i form av ett program.

Programmeringsprinciper i

Java

Programmeringsprinciper i

fadil galji c´

Fadil Galjić c är universitetslektor vid Kungliga Tekniska högskolan i Stockholm. Han har utbildat sig i matematik, programvaruteknik, elektronik och pedagogik och har jobbat som lärare i olika kurser, med olika kategorier studenter. Bokens pedagogiska framställning är baserad på författarens mångåriga erfarenhet och insikter om konsten att lära ut.

Användning av objekt i olika sammanhang behandlas i den mellersta delen av boken. Objekten används i samband med teckensträngar och tal, och för hantering av undantagssituationer i ett program. Ett programs kommunikation med sin omgivning (standardinmatning och -utmatning samt filer) är ytterligare en situation där objekt används. Den avslutande delen går djupare in på objektorienterad programmering och presenterar strategier för att definiera egna typer av objekt. Vidare beskrivs arv, klasshierarkier och gränssnitt. Typoberoende programmering behandlas både i samband med klasshierarkier och i samband med gränssnitt. Programmeringsprinciper i Java kan användas som kurslitteratur för olika programmeringskurser, på såväl universitets- som gymnasienivå och kräver inga förkunskaper. Boken kan även användas av alla som på egen hand vill lära sig programmeringsprinciper och Java.

fadil galji c´

Art.nr 37874

www.studentlitteratur.se

978-91-44-09442-7_01_cover.indd 1

2013-09-13 15.10

Bokens webbplats www.studentlitteratur.se/37874 På webbplatsen: trådar, kommunikation mellan program, grafik, grafiska användargränssnitt och annat.

Kopieringsförbud Detta verk är skyddat av lagen om upphovsrätt. Kopiering, utöver lärares begränsade rätt att kopiera för undervisningsbruk enligt BONUS-Presskopias avtal, är förbjuden. Sådant avtal tecknas mellan upphovsrättsorganisationer och huvudman för utbildningsanordnare t.ex. kommuner/universitet. För information om avtalet hänvisas till utbildningsanordnarens huvudman eller BONUS-Presskopia. Den som bryter mot lagen om upphovsrätt kan åtalas av a llmän åklagare och dömas till böter eller fängelse i upp till två år samt bli skyldig att erlägga ersättning till upphovsman/rättsinnehavare. Denna trycksak är miljöanpassad, både när det gäller papper och tryckprocess.

Art.nr 37874 ISBN 978-91-44-09442-7 Upplaga 1:1 © Författaren och Studentlitteratur 2013 www.studentlitteratur.se Studentlitteratur AB, Lund Omslagslayout: Francisco Ortega Printed by Exakta AB, Sweden 2013

Innehållsförteckning

Förord........................................................................................................... 7 1

Ett Javaprogram ............................................................................... 11 Beskriva en uppgift för datorn ............................................................ 12 Ett Javaprograms struktur.................................................................... 15 Kompilera och exekvera ett Javaprogram ........................................... 18 Utforma och kommentera Javakod..................................................... 24 Mata ut meddelanden ......................................................................... 28

Datalagring ...................................................................................... 31 Lagra data i datorns minne ................................................................. 32 Variabler .............................................................................................. 34 Datatyper i Java ................................................................................... 41 Omvandlingar mellan olika datatyper vid lagringen ......................... 55

Standardinmatning ......................................................................... 61 Mata in data......................................................................................... 62 Mata in tecken..................................................................................... 69 Mata in strängar .................................................................................. 73 Mata in tal ........................................................................................... 78

Operationer med primitiva värden ................................................ 81 Operationer med heltal ....................................................................... 82 Operationer med flyttal....................................................................... 90 Operationer på en variabel.................................................................. 94 Jämförelse av primitiva värden ........................................................... 97 Operationer med booleska värden .................................................... 100

Logik ............................................................................................... 107 Införa logik i ett program .................................................................. 108 Villkorliga handlingar ....................................................................... 110 Upprepningar .................................................................................... 121

Vektorer.......................................................................................... 135 Endimensionella vektorer ................................................................. 136 Flerdimensionella vektorer................................................................ 147 © FÖRFATTAREN OCH STUDENLITTERATUR

Metoder .......................................................................................... 151 Skapa och använda metoder ............................................................. 152 Hantera metoder ............................................................................... 163 Överföring av vektorer mellan olika metoder .................................. 175

Ett klassbibliotek ........................................................................... 181 Distribuerad kod................................................................................ 182 Javas standardbibliotek ..................................................................... 192 En metods undantag ......................................................................... 207

Algoritmer ...................................................................................... 217 Ett problem och en algoritm ............................................................. 218 Urvalsalgoritmer................................................................................ 224 Sorteringsalgoritmer .......................................................................... 235 Sökningsalgoritmer ........................................................................... 254 En algoritms komplexitet .................................................................. 269 En algoritms riktighet........................................................................ 281

10 Objekt ............................................................................................. 305 Definiera, skapa och använda objekt................................................ 306 Objekt som hanterar strängar ........................................................... 321 Typiska tjänster för ett objekt ........................................................... 337 Objektresurser och klassresurser ....................................................... 349 Arv ..................................................................................................... 357 Hantering av objekt........................................................................... 363 Algoritmer i samband med objekt .................................................... 383 11 Undantag........................................................................................ 393 Hantera en undantagssituation......................................................... 394 Olika mönster för undantagshantering ............................................ 408 12 Inmatning och utmatning ............................................................ 427 Ett programs kommunikation med omgivningen............................ 428 Standardinmatning och standardutmatning.................................... 433 Hantera filer....................................................................................... 449 Textfiler ............................................................................................. 453 Binära filer ......................................................................................... 469 13 Skapa nya objekttyper................................................................... 487 Sammansatta datatyper ..................................................................... 488 Ett objekts data .................................................................................. 492 Ett objekts operationer ...................................................................... 506

Ett objekts gränssnitt......................................................................... 516 Objektresurser och klassresurser ....................................................... 525 Ett objekts referenser ......................................................................... 531 Nästlade och inre klasser ................................................................... 554 14 Utveckla nya objekttyper .............................................................. 571 Definiera en ny typ av objekt............................................................ 572 Implementera definitionsklassen ...................................................... 604 Skapa ett testprogram........................................................................ 612 Beskrivning av en definitionsklass.................................................... 622 Skapa, testa och beskriva en ny typ av objekt .................................. 634 15 Arv .................................................................................................. 635 En subklass ........................................................................................ 636 Superklassreferenser och subklassreferenser ..................................... 662 Polymorfism och dynamisk bindning .............................................. 670 16 Klasshierarkier ............................................................................... 677 En klasshierarki.................................................................................. 678 Hantera en klasshierarki.................................................................... 687 Rotklassen i Javas klasshierarki ......................................................... 700 Typoberoende programmering ......................................................... 723 Typoberoende datastrukturer............................................................ 729 17 Gränssnitt ....................................................................................... 747 Definiera och använda objekt av en viss profil ................................ 748 Definiera och använda en uppsättning konstanter .......................... 762 Typoberoende programmering med gränssnitt ................................ 764 Objekt med flera profiler ................................................................... 773 Gränssnitt i samband med inre klasser ............................................. 776 Sakregister............................................................................................. 787

Förord Vad handlar boken om? Konfronterad med ett problem, hittar man och formulerar en lösning till det. Olika steg behöver utföras i en viss ordning. Dessa steg bildar en algoritm. Genom att applicera en viss algoritm på ett givet problem, får man en lösning. Stegen i algoritmen kan så småningom förfinas och preciseras. Algoritmen beskrivs på något sätt. Det går att använda ett vanligt språk eller matematiska uttryck. Det finns många problem och många algoritmer. För många problem är redan lösningarna hittade. Det kan till och med finnas flera algoritmer för ett och samma problem. Vissa av dessa algoritmer kan vara bättre än andra. Kanske en algoritam är enkel och en annan algoritm är snabb. Säg att man vill hitta ett ord i en ordbok. En algoritm kan grovt formuleras så här: gå genom alla ord, i den ordning som används i ordboken, tills du hittar ordet. En annan algoritm kan formuleras så här: öppna ordboken så att du är nära ordet, backa sedan eller gå framåt beroende på var du befinner dig, och upprepa detta tills du hittar ordet. Båda dessa algoritmer ger lösningen till problemet. Men i genomsnitt är den andra algoritmen mycket snabbare. Så man kan föreställa sig att det finns många problem och många procedurer som leder till lösningen. Många algoritmer är redan tillgängliga, andra kommer att hittas i framtiden. Många problem i matematik, fysik, teknik, ekonomi och andra områden kan lösas nu. Olika problem kan lösas med datorns hjälp. Datorerna kan jobba åt oss. Det är ett program på en dator som kan hitta ett ord åt oss, i en elektronisk ordbok. Motsvarande synonymer eller översättningar kan sedan presenteras snyggt på datorns skärm. Med olika program på en dator kan vi även rita, kommunicera, utföra matematiska beräkningar, skapa textdokument, och så vidare. Ett program består av flera mindre delar, flera enheter. I grunden finns små enheter som löser vissa grundläggande problem. Genom att kombinera flera sådana enheter skapar man en större enhet. Så småningom kan man bygga ett användbart program. För att kunna lösa ett problem behöver man en lämplig algoritm. Man kan följa stegen i algoritmen och komma fram till lösningen. Men om ett program på en dator ska lösa problemet, måste dessa steg presenteras på så sätt att datorn kan förstå och utföra dem. Det måste finnas ett språk © FÖRFATTAREN OCH STUDENLITTERATUR

Förord

som både datorn och människor förstår, och algoritmerna måste kodas i detta språk. Det finns många sådana språk, och Java är ett av dem. Det går att beskriva de olika algoritmerna i detta språk. Det går att skriva instruktioner till dator, att programmera. Det finns ett antal grundidéer i programmeringen. Det finns vissa data som hanteras på något sätt. Det ska gå att lagra de olika uppgifterna, och att utföra olika operationer med dem. Vissa steg ska upprepas flera gånger, och andra steg ska inte alls utföras vid en exekvering av ett program, allt beroende på aktuella omständigheter i programmet. Data kan organiseras på olika sätt. Mindre dataenheter ska kunna grupperas, och olika operationer ska definieras i samband med dessa större enheter. Vissa uppgifter kan vara besläktade på något sätt och kan hanteras på ett speciellt sätt. Det ska gå att definiera programenheter och binda dem på olika sätt. Det finns även andra idéer som man stöter på när man börjar skapa olika program för en dator. Den här boken tar upp dessa grundläggande idéer, principer, grundbegrepp som gäller datorprogram. Man lär sig grunderna av programmeringen. Man ska förstå dessa grundidéer och kunna använda dem för att koda sina egna algoritmer, att skapa sina egna program. Det finns olika stilar att programmera. Java är ett programmeringsspråk som uppmuntrar användning av objekt. Därför gäller en stor del av den här boken teori av objekt. Det går att definiera och skapa objekt som kan utföra olika tjänster. Dessa objekt används för att uppnå olika mål. Man ska kunna designa egna objekt för att kunna utföra specifika funktioner. Java är ett programmeringsspråk som mest används i världen. Den används både av professionella programmerare och i den akademiska världen. Det är ett språk som lätt känns igen och används i olika sammanhang. Det är lätt att lära sig programmera i Java. som är ett uttrycksfullt språk. När man väl lärt sig programmera i Java, blir det inte så svårt att lära sig även programmera i andra språk. Det finns många gemensamma idéer som gäller programmeringen. Det är dessa idéer som är det huvudsakliga målet för den här boken, och de förstås bäst i ett konkret sammanhang och i ett konkret språk. Enligt dessa riktlinjer lär denna bok ut programmeringsprinciperna i Java.

Bokens organisation Den här boken beskriver och illustrerar olika programmeringsbegrepp. Målet var att skapa ett material som å ena sidan är grundligt och undersökande, och å andra sidan lätt att följa och förstå. Ideérna dyker upp i ett naturligt sammanhang, belyses först, och utvecklas därefter i olika rikt-

Förord

ningar. Därefter presenteras nya tankar, och ett system av idéer sätts så småningom samman. Det finns också en bok med exempel. Här illustreras varje begrepp med ett eller flera program. Tillsammans med ett program finns även en kortfattad beskrivning av begreppet. Inuti ett program finns olika kommentarer, som hjälper att olika delar i programmet rätt förstås. Det finns också en utskrift som programmet skapar när det körs. Dessa illustrativa exempel bidrar till att idéerna kan förstås, assimileras och tillämpas. Det finns också en bok med övningar. I dessa övningar sätts de olika begreppen i olika sammanhang och belyses från olika sidor. En del uppgifter representerar olika illustrativa situationer i form av färdiga program eller programdelar. Andra uppgifter kräver att egna program ska skapas, där idéerna ska användas. Bara genom en intensiv träning kan man lära sig skriva egna program. Övningsboken hjälper till i detta avseende. Den här boken är en huvudbok. Böckerna med exempel och övningar stödjer ytterligare inlärningen.

Vem ska använda den här boken? Denna bok passar bra som kursbok i de första programmeringskurserna på olika universitet och högskolor. Den kan också användas av vem som helst som vill lära sig programmera i Java.

Tack! Jag utvecklade den här boken på Kungliga Tekniska högskolan i Stockholm, där jag jobbar med olika programmeringskurser. Jag tackar alla, både anställda och studenter, för gynnsamma förhållanden för bokens utveckling. Jag har skrivit den här boken på svenska, som inte är mitt modersmål. ADDISCO Industrial Consulting har språkgranskat boken, så jag tackar dem så mycket för det. Studentlitteraturs medarbetare har varit vänliga och hjälpte mig på olika sätt. Jag tackar alla dem som har bidragit till den här boken. Stockholm, 2013 Fadil Galjic fadil@kth.se © FÖRFATTAREN OCH STUDENLITTERATUR

Kapitel 3 Standardinmatning Mata in data Tillföra data till ett program under exekveringen Tangentbordsinmatning Inmatningsverktyg Mata in ett värde

Mata in tecken Mata in ett tecken Rensa inmatningsbufferten

Mata in strängar Mata in en rad Mata in ett ord Mata in en teckensträng

Mata in tal Mata in numeriska värden Felaktig inmatning

Kapitel 3 – Standardinmatning

Mata in data Tillföra data till ett program under exekveringen Ett program bearbetar olika uppgifter. Dessa uppgifter finns lagrade i datorns minne, så att programmet kan avläsa, använda och eventuellt ändra dem. Vissa av dessa uppgifter är kända i förväg. Andra uppgifter anges, matas in, under programmets gång. En del uppgifter beräknas på något sätt, eller bestäms slumpmässigt. Uppgifter i ett program kan fastställas redan när programmet skapas. Det går att initiera variabler, och det går att tilldela lämpliga värden till variablerna. Variablernas värden är kända redan under kompileringen. Det händer dock ofta att man inte känner till värden av vissa variabler förrän vid programkörningen. Kanske värden behöver tillföras genom tangentbordet. I så fall kan en variabels värde variera från den ena exekveringen till den andra. Variabeln tilldelas alltid det värde som är aktuellt vid programkörningen. När man skapar ett program inför man en viss flexibilitet i programmet. Ett program måste kunna utföra olika bearbetningar av data, oavsett de aktuella värdena för dessa data. Programmet ska inte vara låst till endast en uppsättning värden. Om man, till exempel, skapar ett program som beräknar den totala kostnaden av vissa varor, ska priset på varorna inte fixeras i programmet. Priserna kan ändras med tiden, och man vill ange de aktuella priserna när man kör programmet. Ett och samma program måste kunna bearbeta vissa uppgifter, oavsett de aktuella värdena för dessa uppgifter. Ett program måste kunna kommunicera med sin omgivning. Det måste ha förmåga att hämta aktuella värden på data när det körs. Man ska kunna tillföra olika uppgifter till ett program som exekveras, och programmet ska kunna hämta dessa uppgifter. Man ska kunna mata in olika uppgifter till ett exekverande program. Uppgifterna som tillförs till ett exekverande program kan komma från olika källor. De kan till exempel komma från en fil som finns i den aktuella datorn, eller hämtas från en annan dator, eller matas in via tangentbordet. För varje dator finns det en standardmetod som normalt används för att tillföra uppgifter till det program som exekveras. Detta kallas för standardinmatning eller standard input. Inmatningen utförs med motsvarande fysisk enhet, standardinmatningsenheten (som också kallas för standard

Kapitel 3 – Standardinmatning

input). Man kan, till exempel, använda ett tangentbord och en bildskärm till detta ändamål. I så fall skriver man sina data i ett terminalfönster på skärmen, så att det blir möjligt att följa och korrigera det som matas in. Detta fönster kallas för konsolfönster, och inmatningstypen kallas för konsolinmatning. Konsolfönstret kan även användas för att visa, eller mata ut, olika uppgifter. De program som kommunicerar med sina användare endast via detta fönster kallas för konsolprogram. Ett program kan även skapa egna fönster och använda dessa för kommunikation med användaren. Dessa fönster utgör programmets grafiska gränssnitt mot användaren (eng. GUI, Graphical User Interface). Motsvarande program kallas för grafiska program (GUI-program).

Tangentbordsinmatning När tangentbordet och motsvarande terminalfönster används för inmatningen, stannar programmet på ett ställe under exekveringen och inväntar data. Användaren matar in de aktuella uppgifterna, dessa hämtas av programmet och exekveringen fortsätter. Man måste dock förklara för användaren vilka uppgifter som ska matas in, och i vilken ordning. Programmet bör därför skriva ut ett lämpligt meddelande varje gång data ska matas in. När man matar in uppgifter till ett program, måste man på något vis kunna signalera till programmet att inmatningen är färdig. Detta gör man vanligtvis genom att trycka på returtangenten på tangentbordet. Så länge man inte har tryckt på denna tangent, kan man korrigera det man skrivit. När returtangenten trycks ned hämtar programmet det man skrivit, och exekveringen går vidare. När data matas in via tangentbordet, används normalt en minnesplats, en så kallad inmatningsbuffert, där man samlar de tecken som matas in. Inmatningsbufferten är en plats mellan programmet och användaren. De inmatade tecknen bildar en kö i inmatningsbufferten. Denna kö kallas för inmatningskö. Inmatningen kan korrigeras så länge man inte har tryckt på returtangenten. Man kan ta bort angivna tecken med backstegstangenten, och skriva nya tecken. När man trycker på returtangenten hämtar programmet en eller flera uppgifter från inmatningsbufferten och exekveringen fortsätter. Därefter går inte inmatningen längre att korrigera. Denna typ av inmatning, som sker via en inmatningsbuffert, kallas för buffrad inmatning.

Kapitel 3 – Standardinmatning

För att användaren ska kunna mata in olika uppgifter, anger man lämpliga instruktioner (inmatningsinstruktioner) på vissa ställen i programmet. Man preciserar typen på det som ska matas in och minnesplatsen (variabeln) där det inmatade värdet ska lagras. Man kan, till exempel, på något ställe i ett program mata in värdet för en variabel som heter antal. Det inmatade värdet lagras i så fall på den minnesplats som variabeln representerar. Om variabeln antal är en variabel av typen int, måste man mata in ett värde som kan lagras i variabeln. Det går, till exempel, att ange värdet 12 och trycka på returtangenten. I så fall tilldelas detta värde till variabeln. Ibland kan det hända att man matar in ett olämpligt värde. Man kan, till exempel, ange 12w eller 4000000000 när man matar in värdet för variabeln antal. Eftersom variabeln är av typen int, går någon av dessa uppgifter inte att lagra i variabeln. I sådana fall måste programmet reagera på ett lämpligt sätt. Det kan, till exempel, skriva ut ett felmeddelande och invänta en ny inmatning. Det kan dock inte alltid reagera på detta vis. Om det inmatade värdet kommer från en fil på disken i stället för från tangentbordet, kan inte programmet invänta en ny inmatning. I stället ska det skriva ut ett felmeddelande och sedan avslutas. Förutom fel vid inmatningen, kan andra problem uppstå under exekveringen. Dessa fel kallas för runtime-fel. Java innehåller ett system för hantering av dessa undantagssituationer. Detta kallas för undantagshantering eller exception-hantering. I vissa fall kan sådana problem åtgärdas utan att exekveringen behöver avbrytas. Ett program måste vara robust, så att det kan klara sig bra även när olika problem uppstår. En intressant situation uppstår när man anger för få uppgifter vid inmatningen. Man trycker kanske på returtangenten innan man angivit de nödvändiga uppgifterna. I sådana fall ska programmet fortsätta vänta tills alla nödvändiga uppgifter har matats in. En annan intressant situation uppstår om man matar in fler uppgifter än vad programmet förväntar sig. Man kanske anger två tal och trycker på returtangenten, fast programmet endast behöver ett tal. I dessa fall lagras de angivna talen i inmatningsbufferten. Motsvarande inmatningsinstruktion i programmet hämtar det första talet från inmatningsbufferten och lagrar det i en variabel i programmet. Det andra talet blir kvar i inmatningsbufferten. Om ingen inmatning sker senare i programmet, ligger det andra talet kvar i inmatningskön till programmets slut. Men om en ny inmatningsinstruktion kommer längre fram i programmet, väntar inte detta på att användaren matar in nya uppgifter, eftersom dessa uppgifter redan finns i inmatningsbufferten. Programmet hämtar värdet från in-

Kapitel 3 – Standardinmatning

matningsbufferten och fortsätter exekveras. Det kan vara ett lämpligt eller olämpligt värde, beroende av vad programmet förväntar sig att få på detta ställe. Om, till exempel, talet 100000 finns i inmatningsbufferten och programmet vill ha ett värde av typen int inmatat, hämtar programmet detta tal och lagrar det i motsvarande variabel. Men om programmet vill hämta ett värde av typen short uppstår ett problem, eftersom värdet som finns i inmatningsbufferten är för stort för en variabel av typen short. Det bästa är om man endast matar in de värden som ett program behöver vid ett visst tillfälle, så att man inte ackumulerar onödiga uppgifter i inmatningsbufferten. Detta är dock inte alltid möjligt. Ett problem uppstår när man trycker på returtangenten. Även denna tryckning producerar vissa tecken som lagras i inmatningsbufferten. Vilka tecken som produceras i detta fall beror på den aktuella plattformen. På vissa plattformar ger ett tryck på returtangenten tecknet \n (Unicode-koden 10), på vissa plattformar tecknet \r (Unicode-koden 13) och på vissa plattformar både tecknet \n och tecknet \r. Det kan hända att man på ett ställe i programmet matar in ett enda tecken. Man kanske matar in tecknet j för ja, eller tecknet n för nej, för att ange om något ska utföras eller inte. Om man anger j och trycker på returtangenten för att tala om för programmet att inmatningen är klar, matar man egentligen inte bara in j, utan också de tecken som produceras av returtangenten. I så fall finns det två eller tre tecken i inmatningsbufferten. Programmet hämtar endast det första tecknet: resten blir kvar i inmatningsbufferten och bildar där en inmatningskö. Om ett tecken till ska matas in längre fram i programmet, inväntar programmet inte användarens inmatning, utan hämtar i stället det första tecknet i inmatningskön. Detta är det tecken som producerats med returtangenten, inte det som matades in av användaren. Programmet får inte den information som det förväntar sig att få. Det är lätt att inse att dessa tecken som produceras med returtangenten i vissa fall kan skapa problem. De utgör skräptecken som komplicerar inmatningen. Därför måste man i vissa fall rensa (tömma) inmatningsbufferten efter en inmatning, för att inte störa de efterföljande inmatningarna. Man måste vara medveten om dessa tecken som produceras med returtangenten och hantera dem på ett lämpligt sätt. En tryckning på returtangenten signalerar till programmet att det kan hämta data från inmatningsbufferten, men producerar också ett eller flera tecken som läggs till i inmatningsbufferten.

Kapitel 3 – Standardinmatning

Inmatningsverktyg För att kunna mata in olika uppgifter i ett program behöver man ett lämpligt verktyg. Java tillhandahåller olika verktyg för detta ändamål, och dessa kan man använda fritt. Ett inmatningsverktyg är en kod som finns på någon plats, som man kan aktivera från sina program. Det är denna kod som utför inmatningen. Koden är organiserad i olika klasser som ingår i Javas så kallade standardbibliotek. Javas standardbibliotek består av en stor samling klasser som kan användas för olika ändamål. Biblioteket är inte en del av språket Java, men följer med som ett komplement till språket. Javas standardbibliotek finns på alla Javastandardplattformar, och man kan använda bibliotekets olika klasser i sina program. Vissa funktioner i programmen kan implementeras med olika klasser i standardbiblioteket. Man kan åstadkomma in- och utmatning, hantera text, bild och ljud, hantera olika undantagssituationer, med mera. En klass i Javas standardbibliotek innehåller vanligtvis flera enheter, så kallade metoder. Man använder dessa metoder för att åstadkomma olika funktioner i programmen. En metod från en klass anropas på ett visst ställe i ett program. Exekveringen flyttas till denna metod, den motsvarande koden utförs och sedan återgår exekveringen till det anropande programmet. Man lämnar tillfälligt den klass som innehåller huvudprogrammet och går till en metod som finns i en annan klass, som tillhör Javas standardbibliotek. Det är lätt att inse att Javas standardbibliotek är en stor tillgång som innehåller ett stort antal olika rutiner. Det är viktigt att man känner till dessa rutiner och vet hur de ska användas. Standardbiblioteket används även när man skriver ut ett enkelt meddelande. Ett meddelande till standardutmatningsenheten kan skrivas ut så här: System.out.println ("Obegränsat lugn!");

I denna sats anropas en metod i Javas standardbibliotek. Denna metod heter println, och anropas via ett objekt som heter out. Detta objekt är ett fördefinierat objekt i klassen System. Efter anropet hoppar programmet till denna metod och exekverar koden som finns där. Det är egentligen den koden som skriver ut det angivna meddelandet till standardutmatningsenheten. När den anropade metoden avslutas återgår exekveringen till det anropande programmet, och fortsätter direkt efter platsen för metodanropet. Olika typer av inmatning kan utföras på liknande sätt. Man måste därför känna till de klasser i Javas standardbibliotek som kan användas för detta ändamål. Man använder en passande metod från en sådan klass för att

Kapitel 3 – Standardinmatning

mata in en uppgift av en viss typ. Att använda dessa klasser och metoder är en relativt avancerad uppgift, som kräver vissa kunskaper om paket, objekt, metoder och undantagshantering. Det är därför svårt för en nybörjare i programmering att använda sig av dessa klasser. Inmatning av data är dock en grundläggande funktion, som behövs även i mycket enkla program. Ett enkelt program får vissa uppgifter från sin omgivning, bearbetar dessa uppgifter och skriver sedan ut olika meddelanden och resultat. Det blir onaturligt att fortsätta lära sig programmera om man inte får lära sig hur man matar in olika uppgifter. Man behöver därför lära sig använda åtminstone en del av de inmatningsmöjligheter som finns i Javas standardbibliotek. Man kan lära sig att använda vissa verktyg, även om man inte förstår hur verktygen är konstruerade. För inmatning av teckensträngar och primitiva värden kan man använda ett objekt av typen Scanner. Denna klass finns i paketet java.util, och dess fullständiga namn är därför java.util.Scanner. Ett objekt av typen Scanner kan skapas med operatorn new och motsvarande konstruktor från klassen Scanner. Man kan göra så här: java.util.Scanner

in = new java.util.Scanner (System.in);

Man skapar ett objekt av typen Scanner, och använder namnet in (man kan använda ett godtyckligt namn) för att kunna komma åt det objektet. I fortsättningen ska objektet användas via detta namn. Man tillför fördefinierade objektet System.in som argument till motsvarande konstruktor. På så vis binds det skapade objektet till standardinmatningsenheten. När ett objekt av typen Scanner väl har skapats, är det lätt att mata in olika uppgifter med hjälp av objektets olika metoder. Dessa metoder är: nextLine, next, nextInt, nextDouble, och så vidare.

Mata in ett värde Säg att man vill mata in ett heltal av typen int på någon plats i ett program. Detta kan man göra med ett objekt av klassen Scanner, och dess metod nextInt. Om man har skapat ett objekt av typen Scanner som går att komma åt via namnet in, kan objektets metod nextInt anropas på följande vis: in.nextInt ();

I denna sats matar man in ett heltal av typen int. Metoden nextInt väntar tills användaren anger ett lämpligt heltalsvärde och trycker på returtangenten. Därefter hämtar metoden detta värde från inmatningsbuffer-

Kapitel 3 – Standardinmatning

ten och lagrar det på ett visst ställe. Det inmatade heltalet tas dock inte om hand, och kan inte heller nås och användas senare i programmet. Det måste lagras någonstans i programmet. Så här kan man göra: int tal; tal = in.nextInt ();

Här skapas först variabeln tal. Därefter matas ett heltal in som lagras i denna variabel. Det inmatade heltalet kan nu användas i programmet. Det går att skapa plats för att lagra det inmatade heltalet och mata in det i en enda sats: int

tal = in.nextInt ();

Man skapar variabeln tal och anropar metoden nextInt i samband med objektet in. Metoden matar in ett heltal av typen int och lagrar det på ett tillfälligt ställe. Sedan kopieras det inmatade värdet till variabeln tal med tilldelningsoperatorn. På så vis avslutas inmatningen, och efter det kan det inmatade värdet användas. Det kan till exempel visas på standardutmatningsenheten: System.out.println ("Det inmatade talet är: " + tal);

Ett program kan tillföras olika värden under exekveringen. Det går att tillföra olika uppsättningar värden till ett och samma program vid olika exekveringar av det. På så sätt får man ett program som kan bearbeta ett antal uppgifter, oavsett vilka värden dessa uppgifter har. Man får ett flexibelt program.

Kapitel 3 – Standardinmatning

Mata in tecken Mata in ett tecken Ibland behöver man mata in ett tecken under exekveringen av ett program. Det kan gälla att mata in j (för ja) för att välja en rutin, eller n (för nej) för att inte välja rutinen. Man kan mata in siffror, bokstäver och andra tecken. För teckeninmatning kan ett objekt av klassen InputStreamReader användas (klassen java.util.Scanner saknar metoder för teckeninmatning). Denna klass finns i paketet java.io, varför dess fullständiga namn är java.io.InputStreamReader. Ett objekt av klassen kan skapas och bindas till standardinmatningsenheten så här: java.io.InputStreamReader in = new java.io.InputStreamReader (System.in);

Klassen InputStreamReader innehåller metoden read, som kan mata in enskilda tecken från standardinmatningsenheten. Metoden väntar tills användaren anger ett tecken och trycker på returtangenten. När användaren trycker på returtangenten hämtar metoden det inmatade tecknet från inmatningsbufferten och lagrar det på en bestämd plats. Metoden read returnerar egentligen Unicode-koden för det inmatade tecknet. Koden returneras som ett heltal av typen int. Metoden read kan anropas så här: int

i = in.read ();

När satsen utförs väntar programmet tills användaren anger ett tecken och trycker på returtangenten. Därefter hämtar programmet det inmatade tecknet och returnerar dess Unicode-kod. Om till exempel tecknet A matas in, returnerar metoden 65. Det returnerade värdet lagras i heltalsvariabeln i och kan därefter användas. Metoden read returnerar ett heltalsvärde som representerar det inmatade tecknets Unicode-kod. Om man vill ha det inmatade tecknet som ett värde av typen char, måste man omvandla heltalsvärdet till datatypen char. Detta kan göras på följande vis: char

c = (char) in.read ();

Här skapas teckenvariabeln c, och det inmatade tecknet lagras i denna variabel. I stället för att skapa en variabel i samband med inmatningen kan en tidigare skapad variabel användas:

Java

Programmeringsprinciper i

Java

Programmeringsprinciper i

Java

Programmeringsprinciper i

fadil galji c´

Art.nr 37874

www.studentlitteratur.se

978-91-44-09442-7_01_cover.indd 1

2013-09-13 15.10