What we have to learn to do we learn by doing.
Aristoteles
if-setningerDet finnes to hovedtyper av java-programmer:
Et applet-program er beregnet på å skulle kjøres av en nettleser som del av en internett-side. Applet-programmer kan også kjøres av javas appletframviser.
En applikasjon er et program som er beregnet på å kunne kjøres uavhengig av nettleser, men som kan kommunisere over nettet. Det er denne type program vi vanligvis lager.
Enten det dreier seg om den ene eller den andre programtypen, består som nevnt et java-program av en samling av klassedefinisjoner. Det grunnleggende rent programmeringsmessig vil imidlertid være likt, enten programmet er en applikasjon eller en applet. Det er de samme grunnleggende programkonstruksjonene som må brukes i begge tilfeller. Om programmet skal kunne kjøres som en applikasjon eller en applet, er avhengig av det vi kan tenke på som "innpakningen" til programmet. Skillet mellom de to typene er imidlertid ikke større enn at det går an å lage de fleste programmer slik at de kan kjøres både som en applikasjon og som en applet. Programeksemplene i denne introduksjonen til programmering er applikasjoner. Appleter vil bli tatt for seg i et eget kapittel.
Alltid når vi skal lære noe nytt, må vi begynne med det enkle og grunnleggende. Det er først når vi behersker dette, at vi har grunnlag for å lære de mer avanserte delene. I dette kapitlet skal vi ta for oss noen grunnleggende programelementer og illustrere bruken av disse i noen enkle programeksempler.
Vi ser nærmere på følgende program:
1 public class Velkommen 2 { 3 public static void main(String[] args) 4 { 5 System.out.println("Velkommen til java-programmering!"); 6 } 7 }
Programmet må skrives inn i TextPad, slik det ble forklart i forrige kapittel, og lagres i en java-fil som heter
Velkommen.java.
Vi merker oss her at java-filas fornavn stemmer nøyaktig overens med
klassenavnet Velkommen for klassen som
definerer programmet. Dette er et krav når nøkkelordet
public brukes foran
class slik det er gjort her.
Nøkkelordet class signaliserer at her begynner
en klassedefinisjon. Klassens innhold er avgrenset av krøllparentesene { }.
Fila har etternavn .java. All java-kode
som skal brukes i et program må ligge i filer med etternavn
.java. Linjenumrene som står forrest på hver linje er ikke en del
av programmet. I en editor kan vi vanligvis velge om vi ønsker at den skal vise
linjenumre eller ikke. De er her bare tatt med for at det skal kunne være
enklere å referere til de enkelte linjene i programmet. I forrige kapittel ble det
forklart hvordan du kan få vist linjenumre i TextPad.
Merknad Du bør allerede fra starten lagre filene dine på en systematisk måte i kataloger og underkataloger som blir navngitt på en slik måte at du seinere skjønner hva katalogene inneholder av filer. Ellers vil du ganske fort miste oversikten og ha store problemer med å finne igjen programmer som du vet at du har lagret. I forelesningene blir det gitt nærmere råd og anbefalinger for hvordan dette bør gjøres.
Alle applikasjoner må inneholde en metode som heter
main og som skrives slik:
public static void main(String[] args) { // her skal det stå instruksjoner som skal utføres }
Det er i main-metoden programutførelsen
starter opp når et applikasjonsprogram kjøres. I eksemplet ovenfor er
main-metoden det eneste som klassen
inneholder. Klassens main-metode
inneholder én eneste instruksjon: en utskriftsinstruksjon som
skriver ut tekst i det såkalte konsollvinduet. Alle instruksjoner
avsluttes med semikolon ;.
Resultatet av å kjøre programmet ble vist allerede i forrige kapittel, men vi gjentar bildet her:
Figur 0
En annen ting som vi merker oss i programmet, er plassering av parenteser og bruk av innrykk. For hver ny blokk foretas et innrykk av innholdet til blokka. (Vi husker fra kapittel 1 at en blokk er en samling av java-kode som er avgrenset av krøllparenteser {}.) TextPad har en automatikk for dette på den måten at når du har skrevet en krøllparentes { på en linje og så trykker på returtasten, så vil du på neste linje automatisk få et innrykk på to tegn. (Det forutsettes at TextPad allerede vet at det er en java-fil.) Dersom du så forrest på en ny linje skriver en avslutningsparentes } så vil denne automatisk bli rykket to tegn mot venstre, slik at den får samme avstand til venstre kant som den tilhørende startparentesen har. Når vi passer på å skrive programkode slik at dette er oppfylt, blir det mye lettere å se hva som hører sammen av programkode, slik at det også blir lettere å finne eventuelle feil i programmet.
Det svarte konsollvinduet er nokså primitivt i den forstand at det bare kan vise rein tekst som inneholder bokstavene i det engelske alfabetet, samt vanlige skilletegn og noen spesialtegn. Det kan ikke vise de norske bokstavene æ, ø og å. Det vi er vant med er at hvert program har sitt eget vindu på skjermen. Også for java-programmer blir det vanligvis opprettet et eget vindu på skjermen. Konsoll-vinduet brukes som regel bare til utskrift av eventuelle feilmeldinger og andre hjelpeutskrifter. I programeksemplet ovenfor ser du hvordan du kan få skrevet ut en tekst i konsoll-vinduet. I det neste eksemplet skal vi se hvordan vi kan få skrevet ut en tekst i et eget, grafisk vindu på skjermen, i dette tilfelle et hjelpevindu av den typen som blir kalt dialogboks. Det blir dessuten vist hvordan du kan få splittet opp en tekst slik at den vises over flere linjer i utskriften.
I alle java-programmer er det nødvendig å bruke eksisterende programkode
fra javas store klassebibliotek. Klassebiblioteket er delt opp i såkalte
pakker. Pakken som heter java.lang blir
automatisk importert til alle programmer. I det første eksemplet vårt ble det
bare brukt ting fra denne. (Vi brukte instruksjonen for å få utskrift av
tekst i konsoll-vinduet.) Dersom vi skal bruke noe fra andre pakker, må vi
forrest i java-fila (eventuelle kommentarer kan stå aller først) skrive
import-instruksjoner for pakkene eller klassene
vi vil importere. Mange av de klassene som definerer grafiske skjermkomponenter,
for eksempel vinduer, ligger i pakken javax.swing.
Denne får vi bruk for i det neste programeksemplet.
I programmet Dialogboks skal vi bruke en klasse
JOptionPane som ligger i pakken
javax.swing. For å
importere den skriver vi derfor
import javax.swing.JOptionPane;
forrest i java-fila for programmet. Det totale innholdet i fila ser ut slik:
1 import javax.swing.JOptionPane; 2 3 public class Dialogboks 4 { 5 public static void main(String[] args) 6 { 7 JOptionPane.showMessageDialog(null, "Hallo!\n" + 8 "Dette programmet\n" + 9 "har jeg laget!"); 10 } 11 }
For å få kjørt programmet, må du skrive inn programkoden i TextPad og lagre den i en fil
Dialogboks.java, på tilsvarende måte som det ble gjort for programmet
Velkommen. Her skal vi se nærmere på hva de enkelte
delene av selve java-koden betyr og hvilken virkning de har.
Klassen JOptionPane inneholder metoder som
kan kalles opp for å vise på skjermen dialogbokser av forskjellige typer. I vårt
eksempel skal vi vise en dialogboks av type
MessageDialog.
Vi ønsker at dialogboksen skal inneholde teksten
Hallo!
Dette programmet
har jeg laget!
fordelt på tre linjer slik som her. For å få til dette, skriver vi instruksjonen
JOptionPane.showMessageDialog(null, "Hallo!\n" + "Dette programmet\n" + "har jeg laget!");
Instruksjonen er et kall på metoden showMessageDialog, som er
definert i klassen JOptionPane. En metode er kort og godt en
navngitt samling av instruksjoner. Navnet er altså i dette tilfelle
showMessageDialog. Å gjøre kall på metoden, slik vi har et
eksempel på her, har som virkning at de instruksjonene som metoden inneholder
blir utført. Virkningen av instruksjonene er altså i dette tilfelle å vise
på skjermen en bestemt type dialogboks, se figur 1 nedenfor.
Det som står mellom parentesene i kallet på showMessageDialog,
kalles parametre. Det er i dette tilfelle to parametre, atskilt med komma. Den første
parameteren, null, har i dette tilfellet som
virkning at den dialogboksen som blir vist på skjermen (når programmet kjøres),
blir plassert midt på skjermen. Den andre parameteren er den teksten som
dialogboksen skal inneholde.
Alle instruksjoner i et java-program avsluttes med semikolon ;
Vi skal se nærmere på den teksten som skal vises i dialogboksen.
Sammensetningen \n er et såkalt
escape-tegn. Escape-tegn begynner med \. Escape-tegnet
\n har som virkning at det som står etter
tegnet vil komme på en ny linje ved utskrift fra programmet. For øvrig er det
slik at konkret tekst som skal brukes på en eller annen måte av programmet,
alltid må avgrenses med doble sitattegn: " ". Dersom vi trenger å fordele
teksten over flere linjer i programkoden, må vi dele den opp i biter som
vi skjøter sammen med pluss-tegn slik som vist i eksemplet ovenfor.
Istedenfor utskriftsinstruksjonen som står ovenfor, kunne vi ha skrevet
instruksjonen
JOptionPane.showMessageDialog(
null, "Hallo!\nDette programmet\nhar jeg laget!" );
Det hadde gitt nøyaktig samme utskrift på skjermen. Men den første versjonen av instruksjonen gir en kildekode som likner mer på utskriften som koden gir: tekst som kommer på en ny linje på utskriften er også plassert på en ny linje i kildekoden. For datamaskinen spiller det ingen rolle hvilken av versjonene vi bruker. Men for mennesker som skal lese programmet, vil sannsynligvis de fleste synes at den første versjonen er lettere å lese og forstå fordi den er litt mer oversiktlig og har en layout som ligger nærmere det resultatet den skal gi.
Dialogboksen som kommer opp på skjermen når vi kjører programmet vil se ut omtrent som vist på figur 1. (Vindusutseendet vil variere litt med hvilken maskinplattform programmet blir kjørt på.)
Figur 1
Dialogboksen vil bli stående åpen, det vil si den vil bli vist på skjermen, inntil vi lukker den ved å klikke på dens OK-knapp, eller dens lukkeknapp i øverste høyre hjørne. Først da vil programmet komme videre til neste instruksjon. I dette programmet er det ingen flere instruksjoner. Det vil da automatisk bli avsluttet.
***
De programmene vi har tatt for oss hittil kan vi si har vært vært reint statiske eller passive: De har skrevet ut noe tekst, tekst som ble ferdigskrevet inne i selve kildekoden til programmet. Det vi normalt ønsker oss av et dataprogram, er at vi skal kunne kommunisere med det, det vil si at vi skal kunne gi programmet input, altså tilføre det dataverdier utenfra på en eller annen måte, og at programmet skal bruke disse til å gi oss resultater som avhenger av hvilken input vi gir det. For å oppnå dette, er det en del nytt vi må lære. Vi må blant annet lære hvordan vi kan få programmet til å lagre dataverdier, og hvordan vi kan få det til å lese inn dataverdier fra oss. Dette skal vi ta fatt på nå.
Datamaskinen har flere forskjellige typer lagerområder for data. De skiller
seg fra hverandre blant annet når det gjelder lagerkapasiteten og hvor raskt
tilgjengelig de lagrede dataene er. Det viktigste lagerområdet for oss som
programmerere er det vi kan kalle
maskinens hurtiglager eller memory. Vi kan forestille oss at dette består av et stort antall
celler (lagerplasser) der hver celle har sin egen adresse og kan lagre én
enkelt verdi.
Når vi skal reservere lagerplass for en verdi, må vi gi verdien et navn.
En slik navngitt verdi, som kan endre seg mens programmet utføres,
kalles en variabel. Siden dataverdier kan være av vidt forskjellig type
— det er for eksempel forskjell mellom tallverdier og tekst —
er det vel ikke urimelig at vi må angi hvilken type verdier en variabel kan ha.
Vi sier at vi må tilordne variabelen en datatype. I java-språket og
det tilhørende klassebiblioteket er det noen forhåndsdefinerte datatyper,
blant annet for tallverdier og tekst. Datatypen for vanlige heltall (0, 1, 2
etc., eventuelt med fortegn) heter int,
som er et av java-språkets
nøkkelord. (Betegnelsen int kommer fra det engelske ordet for
heltall: 'integer'.) Datatypen for tekst (eller tekststrenger, som vi også sier,)
heter String. Denne er definert
i javas klassebibliotek, i form av en klasse, derfor stor forbokstav i navnet.
(String er ikke noe nøkkelord, men derimot navnet på den klassen
som definerer datatypen.) Vi skal seinere lære å definere våre
egne datatyper i form av klasser.
Navn på variable og andre ting som
må navngis i et dataprogram, blir i lærebøker kalt for identifikatorer.
Alle slike må ha en bokstav som første tegn og de må bestå av ett
sammenhengende ord (eller tekststreng, som vi også sier). Ord som tilhører
java-språkets nøkkelord, slik som for eksempel
import, public, class og
int, er det ikke tillatt å bruke som
identifikatorer. For øvrig bør vi alltid bruke det vi kan kalle
selvforklarende navn, det vil si navn som indikerer hvilken rolle vedkommende
variabel (eller annet som navngis) skal spille i programmet.
Som tidligere nevnt, er det i java-programmer nesten bare i klassenavn at
vi bruker stor forbokstav. Variabelnavn skal derfor begynne med en liten
bokstav. Når vi i et program innfører en variabel med tilhørende datatype, sier
vi at vi deklarerer variabelen.
Deklarasjon av to tekstvariable for fornavn og etternavn til en person:
String fornavn; String etternavn;
Når flere variable er av samme datatype, er det også tillatt å liste dem opp med komma imellom. Deklarasjonene ovenfor kunne vi derfor også ha skrevet slik:
String fornavn, etternavn;
Merk deg for øvrig at også deklarasjoner, slik som alle andre instruksjoner, blir avsluttet med et semikolon ;.
Å deklarere en variabel har bare som virkning at det blir reservert lagerplass for en verdi av den typen vi spesifiserer. Det blir ikke lagret noen bestemt verdi på dette stedet. For å få gjort det, må vi bruke en tilordningsinstruksjon. En tilordningsinstruksjon har formen
variabel = verdi;
Virkningen av dette er at variabelen på venstre side av = blir tildelt
som verdi den verdien som er på høyre side av =. (Ordet variabel
er her ment å indikere at det på dette stedet skal stå navnet til en variablel,
som vi på forhånd har deklarert som forklart ovenfor. Ordet verdi
er ment å indikere at det på dette stedet skal stå en verdi av den datatypen
som er spesifisert for variabelen som står på venstre side av =.)
NB! Tegnet = fungerer her ikke som et likhetstegn! Vi kaller tegnet = tilordningsoperatoren. Når vi leser tegnet, kan vi lese det som 'settes lik'. Tilordningsinstruksjonen ovenfor kan vi altså lese som 'variabel settes lik verdi'.
Når vi har deklarert variablene fornavn og
etternavn slik det er gjort ovenfor,
kan vi utføre følgende tilordningsinstruksjoner. Virkningen av
hver instruksjon er skrevet som en kommentar bak den.
fornavn = "Tone"; //variabelen fornavn får verdien "Tone". etternavn = "Veli"; //variabelen etternavn får verdien "Veli".
Å deklarere en variabel vil altså si å reservere lagerplass for en bestemt type verdi ved at vi spesifiserer et navn og en datatype. Navnet kan vi dels oppfatte som navnet på verdien som ligger lagret, dels oppfatte som navnet på selve lagerplassen (eller adressen til denne). Det kommer litt an på sammenhengen, men iallfall i første omgang kan du oppfatte variabelnavnet som navnet på den verdien som blir lagret.
Med innlesing menes her innlesing av verdier som brukeren skriver
på sitt tastatur. Innlesing av verdier fra filer blir ikke berørt i denne
introduksjonen. Innlesing av verdier kan skje på forskjellige måter.
Vi skal her ta for oss innlesing av verdier som brukeren skriver i et
tekstfelt i en dialogboks for innlesing. En slik dialogboks er av type
InputDialog. Et eksempel på en slik
boks er vist i figur 2.
Figur 2
Denne kommer fram på skjermen som et resultat av å utføre instruksjonen
JOptionPane.showInputDialog( "Hva heter du?" );
Vi ser at vi også for slike dialogbokser gjør bruk av klassen
JOptionPane. Klassen må derfor importeres til
programmet. Men nå gjør vi kall på en annen metode enn vi gjorde da vi skulle
vise dialogbokser av type MessageDialog:
Vi gjør kall på metoden showInputDialog. Generelt vil metoder
ha et navn som indikerer virkningen av å kalle dem opp.
Teksten "Hva heter du?" som vi har brukt som parameter i metodekallet,
får vi ut som ledetekst til tekstfeltet som innlesingsboksen
inneholder. Dermed kan vi selv bestemme hvilken ledetekst vi vil ha.
Dersom vi klikker på innlesingsboksens Cancel-knapp eller lukkeknapp (i øverste høyre hjørne), vil den bare lukke seg (forsvinne fra skjermen) uten at noe annet skjer. Dersom vi klikker på OK-knappen eller trykker på retur-tasten på tastaturet, vil det som er skrevet i innlesingsboksens tekstfelt bli lest inn til programmet til det stedet der instruksjonen for å vise boksen står. Her er det to viktige ting vi må merke oss:
Siden innlesing alltid skjer i form av en tekststreng, må vi lagre det som
blir lest inn i en variabel av type String.
Denne må stå på venstre side i en tilordningssetning der vi på høyre side
mottar den verdien som blir lest inn. I dette tilfellet kan vi derfor få lest
inn og lagret det brukeren skriver ved at vi skriver følgende kode:
String navn; //deklarerer variabel som skal brukes til lagring navn = JOptionPane.showInputDialog( "Hva heter du?" ); //leser inn og lagrer det som er skrevet
Husk at i en tilordningsinstruksjon er det alltid høyre side som
utføres først. I dette tilfellet vil det derfor virke slik at først
blir dialogboksen for innlesing vist på skjermen. Etter at brukeren har
skrevet sin verdi og trykket retur-tast (eller klikket OK), blir verdien lest
inn og tilordnet som verdi til variabelen
navn.
Vi skal ta for oss et lite program som leser inn navn slik det er forklart ovenfor og bruker det innleste navnet som del av en liten hilsen som skrives ut. Programkoden ser ut som følger:
1 import javax.swing.JOptionPane; 2 3 public class Hilsen 4 { 5 public static void main(String[] args) 6 { 7 String navn; 8 navn = JOptionPane.showInputDialog("Hva heter du?"); 9 String utskrift; 10 utskrift = "Hei på deg " + navn; 11 JOptionPane.showMessageDialog(null, utskrift); 12 } 13 } 14
I tillegg til den nevnte String-variabel for lagring av det
innleste navnet, blir det deklarert en String-variabel
utskrift for den teksten som skal skrives ut. Denne blir tilordnet
verdi ved hjelp av denne tilordningsinstruksjonen:
utskrift = "Hei på deg " + navn;
Husk at i en tilordningsinstruksjon så vil alltid det som står på høyre
side av tilordningsoperatoren = bli utført først, i dette tilfelle
"Hei på deg " + navn
Tidligere har vi sett eksempler på sammenskjøting av konkrete tekster
ved hjelp av plusstegn. Konkrete tekster er også dataverdier av datatypen
String. I dette tilfelle er det en konkret tekst og en variabel
av type String som blir skjøtt sammen. Da virker det på den måten
at den konkrete teksten blir skjøtt sammen med den verdien som variabelen har
for øyeblikket. Dersom vi ved innlesing skrev Siri i
innlesingsboksens tekstfelt før vi trykket returtast eller klikket på
OK-knapp, vil variabelen navn ha fått verdien
"Siri". (Vi skriver Siri uten sitattegn i
innlesingsboksen.) Resultatet av programkoden
"Hei på deg " + navn
vil da bli "Hei på deg Siri". Siden dette står på høyre
side av tilordningsinstruksjonen for variabelen utskrift, vil
denne teksten i neste omgang bli tilordnet som verdi til denne variabelen.
Merk deg for øvrig at vi må passe på å legge inn det ønskede mellomrommet
mellom deg og Siri bakerst i den første teksten.
Det neste vi ønsker er å få skrevet ut den sammenskjøtte teksten i en meldingsboks
på skjermen. Til det bruker vi instruksjonen
JOptionPane.showMessageDialog( null, utskrift );
Denne kjenner vi nesten igjen fra tidligere eksempler. Forskjellen er at det
da var konkrete tekster som ble skrevet ut, mens det i dette tilfellet isteden står
String-variabelen utskrift som parameter i utskriftsinstruksjonen
vår. Da vil det være den verdien som denne for øyeblikket har som blir skrevet ut.
If you can't solve a problem, you can always look up the answer.
But please, try first to solve it by yourself, then you'll learn more
and you'll learn faster.
Donald E. Knuth
Lag et program som inneholder programkoden ovenfor. Kjør programmet gjentatte ganger med bruk av forskjellig input (tekst som du skriver i innlesingsboksens tekstfelt) og se hva som blir skrevet ut.
Lag et program som leser inn en persons fornavn og etternavn hver for seg (altså i to forskjellige innlesingsinstruksjoner), skjøter dem sammen, og skriver det fullstendige navnet ut igjen som del av en passende tekst. Bruk passende ledetekster ved innlesing, slik at brukeren skjønner hva som skal skrives inn. (Du må selv finne ut hva du vil få behov for av variable i programmet.) Kjør også dette programmet gjentatte ganger, slik at du ser at utskriften varierer med hva du skriver inn.
I eksemplene i læreboka til Deitel og Deitel foretas all brukerkommunikasjon
via konsollvinduet. Formatering av utskrift gjøres da ved hjelp av forskjellige
parametre til metoden System.out.printf, slik det er beskrevet flere steder i læreboka.
Innlesing foretas ved hjelp av en Scanner,
slik det er beskrevet flere steder i læreboka. Vi skal isteden foreta
brukerkommunikasjon ved hjelp av dialogbokser. Bruk av System.out.printf
og Scanner er da ikke aktuelt.
Som nevnt ovenfor, må variable som skal tilordnes heltallsverdier være
av datatypen int. Som vi er vant med fra matematikk, kan vi
bruke plusstegn + for å addere tallverdier.
int førstetall, andretall, sum; førstetall = 17; andretall = 29; sum = førstetall + andretall; // sum vil nå være lik 46
Det er tillatt å tilordne verdi til en variabel samtidig som den blir deklarert. Vi sier da at vi initialiserer variabelen, det vil si gir den startverdi. Dette er det ganske vanlig å gjøre. Programkoden i siste eksempel kunne vi derfor også ha skrevet slik:
int førstetall = 17; int andretall = 29; int sum = førstetall + andretall; // sum vil nå være lik 46
Vi kunne også, enda mer kompakt, ha skrevet den slik:
int førstetall = 17, andretall = 29; int sum = førstetall + andretall; // sum vil nå være lik 46
Det er imidlertid ikke noe mål i seg selv å skrive mest mulig kompakt kode. Det viktigste er at den er oversiktlig og forståelig, både for deg selv og for andre. Skriv derfor slik at du er sikker på hvordan det virker.
Vi ønsker selvsagt at brukeren (den som kjører programmet vårt, enten det er oss selv eller andre) skal kunne ha mulighet for å skrive inn tallverdier til et program, eller sagt med andre ord: Programmet skal kunne lese inn tallverdier utenfra. For brukeren kan dette ta seg ut akkurat som for innlesing av tekst: Ønsket tallverdi skrives i tekstfeltet til en innlesingsboks istedenfor et navn eller en annen tekst. Programmeringsmessing må imidlertid innlesing av tall behandles annerledes. Grunnen til dette er det som allerede er nevnt ovenfor:
Når det dreier seg om tall, betyr dette at det blir lest inn en sifferstreng.
(Vi tar i denne omgang for oss innlesing av hele tall. Innlesing av desimaltall
skal vi se på seinere.)
Som for tekststrenger ellers, vil denne være av datatypen String.
Sifferstrengen vil representere en eller annen tallverdi. (Vi forutsetter her
at det ikke har sneket seg inn noen tegn som ikke er sifre, slik som mellomrom
eller bokstaven O (stor o) istedenfor sifferet 0.) Dersom vedkommende tallverdi
skal brukes nettopp som en tallverdi, for eksempel i en regneoperasjon, vil det
være nødvendig å konvertere den innleste sifferstrengen til den tallverdien
som den representerer. Dette oppnår vi ved å bruke instruksjonen
Integer.parseInt( sifferstreng );
der sifferstreng er en String-variabel som
inneholder den sifferstreng som skal konverteres. (Det blir her foretatt et
kall på metoden parseInt, som er definert i klassen
Integer. Variabelen sifferstreng er parameter i
metodekallet. Variabelen kunne selvsagt hatt et annet navn.) Resultatet av instruksjonen
blir nettopp den tallverdi vi skulle ha tak i. Den vil være av datatypen
int. For at vi skal ha noen nytte av den i programmet vårt, må vi
derfor lagre den i en variabel av denne typen. Dessuten må instruksjonen
ovenfor stå på høyre side av en tilordningsinstruksjon for denne
int-variabelen. Alt i alt kan vi derfor få lest inn og lagret
en heltallsverdi ved å bruke følgende instruksjoner, der ledeteksten som
brukes i innlesingsboksen selvsagt må tilpasses hva som skal leses inn:
String sifferstreng; // brukes for lagring av sifferstrengen som leses inn //leser inn sifferstrengen og lagrer den: sifferstreng = JOptionPane.showInputDialog( "Skriv inn helt tall" ); int tall; // brukes til å lagre tallet som sifferstrengen konverteres til //konverterer sifferstrengen til tall og lagrer tallet: tall = Integer.parseInt( sifferstreng );
Merknad Vi må her forutsette at brukeren virkelig har skrevet sifre
i tekstfeltet for innlesing, og ikke noe annet enn sifre. Ellers vil
konverteringen til tallverdi ikke kunne la seg utføre. (Du får seinere lære hvordan
du kan programmere slik at programmet også behandler eventuell gal input på
en fornuftig måte.) Vi kunne selvsagt brukt et annet navn på
int-variabelen tall.
Som det er nevnt ovenfor i forbindelse med numeriske variable, kan vi bruke plusstegn + for å addere verdiene til numeriske variable. Vi tok for oss et eksempel med følgende programkode:
int førstetall, andretall, sum;
førstetall = 17;
andretall = 29;
sum = førstetall + andretall;
Plusstegnet + er en av
de såkalte operatorene i java-språket. At det er en operator, betyr at det
blir returnert en verdi. Operatoren + virker i dette tilfellet på den måten at
den adderer de to verdiene (det vil si verdiene til de to variablene) som den
har på hver sin side og returnerer summen av disse. Den returnerte summen
blir her brukt på høyre side av en tilordningsinstruksjon, slik at summen blir
tilordnet som verdi til variabelen sum. (Husk at
i en tilordningsinstruksjon er det alltid høyre side som utføres først!)
Merk deg for øvrig at variablene førstetall
og andretall ikke vil få endret sine verdier
som følge av at de blir brukt i en slik summeringsoperasjon.
Operatoren + har forskjellig virkning avhengig av datatypen til de verdiene
den har på hver side av seg. Vi har tidligere brukt operatoren til
sammenskjøting av tekst. I programmet Dialogboks
i Programeksempel 2 skrev vi for eksempel
"Hallo!\n" +
"Dette programmet\n" +
"har jeg laget!"
Her er alle verdier av datatypen String.
Derfor virker plussoperatoren på den måten at den skjøter sammen de
tekststrengene som inngår og returnerer den sammenskjøtte teksten, som da er av datatypen
String.
I instruksjonen
sum = førstetall + andretall;
ovenfor er begge verdiene på de to sidene av plussoperatoren av datatypen
int. Derfor virker den nettopp som vi skulle
forvente oss i dette tilfelle: Den adderer verdiene til de to
int-variablene og returnerer summen i form av en dataverdi av
type int. Men hva skjer dersom vi prøver oss med en
instruksjon som denne (der sum fortsatt er av type int):
"Summen er " + sum
På venstre side av
+ har vi datatypen String, mens vi på høyre
side har datatypen int. Det som finnes på hver
side av + (eller en annen operator) kalles generelt for operander.
Operatoren + virker på den måten at dersom minst én av operandene er av
type String, så blir også den andre operanden
automatisk konvertert til type String og skjøtt
sammen med den andre. I dette tilfelle vil derfor
int-verdien som variabelen
sum inneholder, automatisk bli konvertert til
den tilsvarende sifferstrengen og denne blir skjøtt sammen med tekstrengen
"Summen er ". Dersom for eksempel sum har
verdien 17, vil derfor resultatet bli tekststrengen
"Summen er 17". Merk at det ønskede mellomrommet foran 17 må vi sørge for å
legge inn på slutten av den første tekststrengen! Merk også at
int-variablen
sum ikke vil bli berørt av dette!
Den vil fortsatt eksistere og beholde sin verdi.
Programeksemplet nedenfor bruker den typen instruksjoner som er forklart ovenfor. Du kan laste ned til ditt eget område java-fila som inneholder programkoden ved å klikke på følgende link: Addisjon.java. Programmet leser inn to hele tall fra brukeren (i to forskjellige innlesingsoperasjoner). Tallene blir addert og summen skrives ut. Noen flere kommentarer til programmet kan du finne etter gjengivelsen av programkoden.
1 import javax.swing.JOptionPane; 2 3 public class Addisjon 4 { 5 public static void main( String args[] ) 6 { 7 String førsteSifferstreng; 8 String andreSifferstreng; 9 10 int førstetall; 11 int andretall; 12 int sum; 13 14 // Leser inn første tall fra bruker i form av en sifferstreng: 15 førsteSifferstreng = JOptionPane.showInputDialog( 16 "Skriv inn første hele tall" ); 17 18 // Leser inn andre tall fra bruker i form av en sifferstreng: 19 andreSifferstreng = 20 JOptionPane.showInputDialog( "Skriv inn andre hele tall" ); 21 22 // Konverterer sifferstrengene til tallverdier: 23 førstetall = Integer.parseInt( førsteSifferstreng ); 24 andretall = Integer.parseInt( andreSifferstreng ); 25 26 // Adderer tallene og lagrer summen i variabelen sum: 27 sum = førstetall + andretall; 28 29 // Viser resultatet: 30 JOptionPane.showMessageDialog( null, "Summen er " + sum, 31 "Resultater", JOptionPane.PLAIN_MESSAGE ); 32 } // slutt på main-metoden 33 } // slutt på klassen Addisjon
For å få kjørt dette programmet i TextPad, kan du gå fram som i de foregående
eksemplene og selv skrive inn programkoden i en java-klasse. Men dette kan du slippe
dersom du bruker linken som er gitt til fila Addisjon.java ovenfor og laster
den ned til ditt eget område. Deretter kan du åpne fila i TextPad, kompilere og kjøre.
Gjør dette, slik at du får testet ut programmet!
Alle instruksjonene som skal utføres, står i dette programmet inne i
main-metoden. Instruksjonene blir utført etter
tur i den rekkefølge de står. For at du lettere skal skjønne gangen i
programmet, er det foran noen av instruksjonene skrevet kommentarer som
indikerer virkningen av vedkommende instruksjon. Du har kanskje lagt merke
til at instruksjonen for å vise en meldingsboks på skjermen ser litt
annerledes ut i dette programmet enn det vi har hatt i tidligere
eksempler. Dette skal vi se nærmere på.
Dersom vi kjører addisjonsprogrammet og skriver inn verdiene 37 og 46, får vi som resultat følgende dialogboks
Figur 3
Dersom vi sammenlikner denne med dialogboksen i figur 1 ovenfor, ser vi følgende forskjeller: I den siste er det annen tekst i tittellinja og den inneholder ikke noe ikon. Den siste dialogboksen er resultat av følgende instruksjon:
JOptionPane.showMessageDialog( null, "Summen er " + sum, "Resultater", JOptionPane.PLAIN_MESSAGE );
Det er her brukt fire parametre i kallet på metoden
showMessageDialog (mens kallet for å
få figur 1 bare hadde to parametre).
De fire parametrene har følgende
virkning: Første parameter gjør (i dette tilfelle) at dialogboksen blir
vist midt på skjermen. Andre parameter er den tekst som vises inni
dialogboksen. Tredje parameter er tekst for dialogboksens tittellinje.
Fjerde parameter bestemmer hvilken type ikon som eventuelt skal vises i dialogboksen.
I dette tilfellet blir resultatet at det ikke vises noe ikon i det hele tatt.
Følgende tabell viser de forskjellige ikonene du kan velge mellom og hvilke parametre
du må bruke for å få dem.
| Parameter | Ikon | Beskrivelse |
|---|---|---|
JOptionPane.ERROR_MESSAGE |
 |
Melding om en feil |
JOptionPane.INFORMATION_MESSAGE |
 |
Informasjon |
JOptionPane.WARNING_MESSAGE |
 |
Advarsel |
JOptionPane.QUESTION_MESSAGE |
 |
Det stilles et spørsmål til brukeren. Krever vanligvis at brukeren klikker på en Ja- eller Nei-knapp (eventuelt Yes eller No). |
JOptionPane.PLAIN_MESSAGE |
Ikke noe ikon | Melding uten ikon |
Lag en modifisert versjon av addisjonsprogrammet ovenfor. Programmet
skal fortsatt lese inn to hele tall og addere dem. Men utskriften av
resultatet skal være annerledes. Resultatet skal skrives ut som et
regnestykke som inneholder de to tallene som ble lest inn. Dersom for eksempel
de to tallene som ble lest inn var 13 og 19,
så skal utskriften fra programmet være som vist i følgende meldingsboks.
Variable av datatypen int som vi har brukt i noen eksempler
ovenfor, kan bare brukes på hele tall, positive og negative. Standard datatype
for desimaltall er double. Navnet på denne typen er også et av
nøkkelordene i java-språket. Men merk deg:
Når vi skriver desimaltall, må vi i java-sammenheng skrive
desimalpunktum, slik som i tallet 2.17, ikke desimalkomma, som
er standard i vanlig norsk.
double-variabledouble høyde; høyde = 1.58; double lengde = 17.64;
double-verdierOgså for double-verdier er det slik at innlesing i første
omgang skjer i form av en sifferstreng, som nå også som regel inneholder et
desimalpunktum. (Det er tillatt å lese inn en heltallsverdi og la denne bli
tolket som et desimaltall.) Men når vi skal konvertere den innleste
sifferstrengen til en double-verdi, må vi bruke en annen
instruksjon enn vi gjorde for heltall. Framgangsmåten er vist i følgende
eksempel.
String tallstreng;
tallstreng = JOptionPane.showInputDialog(
"Skriv desimaltall (bruk desimalpunktum)" );
double tall = Double.parseDouble( tallstreng );
Plussoperatoren kan brukes også til å addere double-verdier,
tilsvarende som for heltallsverdier. (Med verdi så menes her enten en variabel
eller en konkret tallverdi.)
Det er også tillatt å ha en verdi av type
double på den ene sida av plusstegnet, og en verdi av type
int på den andre sida (eller motsatt). Når det gjelder datatype
for returverdien (altså summen), så er regelen den at dersom minst
én av verdiene er av type double, så vil også summen
bli av type double.
double d1 = 13.7; double d2 = 3.97; int n = 5; double s1 = d1 + d2; // s1 er lik 17.67 double s2 = s1 + n; // s2 er lik 22.67 String resultat = "Resultatet ble " + s2; //Variabelen resultat inneholder teksten Resultatet ble 22.67
Vi ser her eksempler på forskjellig virkning av addisjonsoperatoren +,
avhengig av datatypene til operandene (det som er på hver side av plusstegnet).
Dersom begge operandene er av type double, blir også resultatet
av denne typen, og lik summen av de to operandene. Dersom begge
operandene er av numerisk type og minst én av dem er av type
double, så blir også verdien til den andre operanden konvertert
til type double og addert til den første. (Dette skjer uavhengig av
hvilken av dem som kommer først eller sist i forhold til plusstegnet.)
Et eksempel på dette har vi i instruksjonen
double s2 = s1 + n;
ovenfor. Merk at selv om dette skjer, så vil fortsatt variabelen n
inneholde int-verdien 5.
I uttrykket
"Resultatet ble " + s2
er én av
operandene av type String. Derfor blir verdien til
double-variabelen s2 konvertert til sifferstreng
og skjøtt sammen med strengen på venstre side av plusstegnet. Men selv om dette
skjer, så vil fortsatt s2 inneholde double-verdien 22.67.
Lag en ny versjon av addisjonsprogrammet. I denne versjonen skal det
leses inn og adderes to desimaltall. (Ledetekstene for innlesing bør endres
slik at brukeren skjønner at det skal skrives inn desimaltall.)
Utskriften skal være tilsvarende som
i oppgave 3, slik det er vist eksempel på i denne meldingsboksen.
Ovenfor har vi sett at operatoren + blant annet kan brukes til å summere to tallverdier. Java har også operatorer for å utføre de andre vanlige regneoperasjonene som vi kjenner fra matematikk. Vi kaller disse operatorene med et fellesnavn for aritmetiske operatorer. Følgende operatorer er definert:
+ | addisjon |
- | subtraksjon |
* | multiplikasjon |
/ | divisjon |
% | rest ved heltallsdivisjon |
Operatorene er binære operatorer: de krever to operander, en på
hver side av operatortegnet. (Unntatt fra dette er + og - som også kan brukes
til å angi fortegn på tallverdier og numeriske variable.)
Datatypen for verdien som operatorene returnerer
er bestemt av datatypene til operandene. Dersom begge operander er av heltallstype,
blir også resultatet av heltallstype. Dersom minst én operand er av
en desimaltallstype, vil resultatet også være av denne typen.
Dette er spesielt viktig i forbindelse med divisjonsoperatoren
/. Dersom begge operander er av heltallstype,
vil denne utføre heltallsdivisjon.
13 / 4 returnerer 3 (heltallsdivisjon)
11 / 4 returnerer 2
2 / 3 returnerer 0
2.0 / 3 returnerer 0.6666666666666666
(16 desimaler).
Operatoren % blir også kalt
modulusoperatoren. Den gir altså rest ved heltallsdivisjon. Du vil
etter hvert se mange eksempler på at dette kan være nyttig.
13 % 4 returnerer 1
11 % 4 returnerer 3
2 % 3 returnerer 2
-7 % 2 returnerer -1
Alltid gjelder at de aritmetiske operatorene vil returnere verdier slik at
følgende likning er oppfylt:
(x / y) * y + (x % y) == x
Det er her forutsatt at x og
y er to
int-variable som på forhånd er deklarert og
tilordnet verdi. Operatoren == (skrevet uten
mellomrom!) er en av javas sammenlikningsoperatorer (eller relasjonsoperatorer).
Vi skal se nærmere på disse seinere. Operatoren
== bruker vi i java på tilsvarende måte som
likhetstegn = i matematikk. (I java er altså likhetstegn = tilordningsoperator
og har en helt annen betydning enn ==.)
Lag et program som leser inn radien til en sirkel i form av et desimaltall
og skriver ut sirkelens areal. (Fra matematikk husker du kanskje at
uttrykket for arealet er Π * r * r, der
r er sirkelens radius. Som verdi for konstanten
Π (pi) kan du bruke 3.14.
Lag et program som virker på følgende måte: Programmet leser inn
brukerens navn og fødselsår. Programmet skal beregne hvor mange år brukeren
fyller i løpet av året og skrive ut dette i en hilsen.
Eksempel: Dersom vi er i år 2011 og programmet leser inn Maria og 1991, så skal programmet skrive
ut (i en meldingsboks):
Hei Maria, i år fyller du 20 år.
Lag et program som leser inn et antall sekunder (heltallsverdi) og skriver ut hvor mange (hele) minutter dette utgjør. (Bruk heltallsdivisjon for å finne det ut.)
Lag en utvidet versjon av programmet du lagde i oppgave 7. Programmet
skal fortsatt lese inn et antall sekunder. Nå skal det skrive ut hvor mange
timer, minutter og sekunder dette utgjør.
Eksempel: Dersom programmet leser inn tallet 11873, så skal det skrive ut
3 timer, 17 minutter, 53 sekunder.
Som i matematikk, kan vi i java danne uttrykk der flere operatorer og
eventuelt parenteser inngår, for eksempel
(32 + 9) * 15 / 7.
Det er klart at resultatet
av å beregne verdien til et slikt uttrykk vil avhenge i sterk grad av
rekkefølgen for utførelsen av de forskjellige regneoperasjonene.
Rekkefølgen er bestemt av følgende regler:
Etter disse reglene vil uttrykket ovenfor få verdien 87. (Husk at det i dette tilfelle dessuten vil bli utført heltallsdivisjon.)
Vi forutsetter at alle variable på forhånd er deklarert og tilordnet verdi. I instruksjonen
x = p * q / r + s % t - u;
vil operatorene bli utført i denne rekkefølge:
* / % + - = .
På grunn av regel nummer 1 ovenfor, kan vi ved parentesbruk få den rekkefølge vi ønsker. For eksempel vil vi i instruksjonen
z = (a - b) * c / (d + e);
få følgende rekkefølge for utførelse av operatorene:
- + * / = .
Det er tillatt å bruke overflødige parenteser. Ved å bruke slike kan vi ofte klargjøre strukturen til et uttrykk. Vi kan for eksempel skrive
y = a + (b * c) + (c * x * x);
Her er det lettere å se hvordan uttrykket er bygget opp enn om vi hadde skrevet
y = a + b * c + c * x * x;
som hadde gitt nøyaktig samme resultat.
Finn verdiene til følgende uttrykk:
8 * 6 / 3 64 % 2 18.0 / 6 10 * 3 - 4 17 / 9 48 / 7 * 2 3 * (17 / 3) + 17 % 3 19.0 / 4.0 92 - 3 * 4 10 % 3
Et logisk uttrykk har verdi true eller
false. Den enkleste form for logisk uttrykk
er en logisk variabel. Det er en variabel av datatypen
boolean. Vi kan for eksempel skrive
boolean ferdig; ferdig = false;
Logiske variable og logiske uttrykk er blant annet til stor nytte når vi har behov for å skille mellom forskjellige alternativer for videre programutførelse, og når vi trenger å avgjøre hvilket alternativ som skal velges blant flere mulige. En mulighet når vi skal foreta slike valg, er å sammenlikne tallstørrelser, for eksempel sjekke om en tellevariabel er mindre enn en bestemt grenseverdi. Dette er tilsvarende som når vi bruker ulikheter i matematikk. De forskjellige tegnene for likhet og ulikhet i matematikk svarer til det som i java kalles relasjonsoperatorer. Disse må vi nå gjøre oss kjent med før vi kan gå videre og se på konkrete eksempler.
Javas relasjonsoperatorer bruker vi for å sammenlikne verdier for
likhet, ulikhet eller rekkefølge. De returnerer alle sammen en logisk verdi,
altså true eller
false. Vi kan derfor bruke relasjonsoperatorene
til å danne logiske uttrykk. Når variablene x
og y er av samme numeriske type
(int eller double)
og er blitt tilordnet verdi, har vi følgende muligheter for sammenlikning:
x == y | "er lik" |
x != y | "er ikke lik" |
x < y | "er mindre enn" |
x > y | "er større enn" |
x <= y | "er mindre enn eller lik" |
x >= y | "er større enn eller lik" |
Felles for alle disse uttrykkene er at det som står i uttrykket enten er
tilfelle, det er "sant": true, eller
det er ikke tilfelle, det er "galt": false.
Vedkommende operator returnerer true
eller false avhengig av om uttrykket er
"sant" eller "galt".
Merk at de operatorene som består av to separate tegn må skrives uten
mellomrom! Videre er det ikke tillatt å skrive
=<, => og
=! istedenfor
<=, >= og
!=. Husk at =
skal alltid stå til slutt i disse sammensetningene. Dette er i samsvar med
den muntlige uttalen av operatorene når vi leser dem, slik det er skrevet i
oversikten ovenfor.
Operatorene == og
!= har lavere prioritet enn de andre
relasjonsoperatorene. Det betyr at dersom flere av operatorene forekommer
i ett og samme uttrykk, vil == og
!= bli utført først etter at
de andre operatorene er utført. Dersom du er i tvil om betydningen av et
uttrykk, kan det være fornuftig å sette inn parenteser. Disse kan også bidra
til å klargjøre strukturen til uttrykket.
Anta at variablene m og n er deklarert og
initialisert på denne måte:
int m = 5; int n = -7;
Avgjør om følgende uttrykk har verdien true eller
false:
m < n n >= m n <= m n > m m != n m == n
if-setningerEn if-setning bruker vi når vi ønsker å
uttrykke at en instruksjon bare skal utføres dersom en bestemt betingelse
er oppfylt. En if-setning har følgende form:
if ( betingelse )
instruksjon
Her er det slik å forstå at istedenfor betingelse skal det stå
et logisk uttrykk, det vil si java-kode som har verdi true eller
false. Istedenfor instruksjon skal det stå den java-kode
som vi ønsker utført dersom betingelse har verdi true.
Dersom betingelse har verdi false, vil
instruksjon ikke bli utført.
Betingelsen som brukes i if-setningen må
altså være en logisk variabel eller et logisk uttrykk, for eksempel en
sammenlikning.
Vi forutsetter at de variablene som brukes allerede er blitt deklarert og har fått tilordnet verdi.
if ( antall != 0 ) snitt = sum / antall; // for å unngå divisjon med 0 if ( uttaksbeløp <= saldo ) saldo = saldo - uttaksbeløp; // for å unngå overtrekk av bankkontoen
Finn ut hvilken verdi variabelen minst har fått etter at
følgende instruksjoner er blitt utført:
int m = 3; int n = -7; int p = 2; int minst = m; if ( n < minst ) minst = n; if ( p < minst ) minst = p;
Programmet Sammenlikning nedenfor leser inn
to hele tall og sammenlikner dem ved å bruke de forskjellige relasjonsoperatorene
som er beskrevet ovenfor. Utfallene av sammenlikningene brukes som betingelser
i if-setninger for å avgjøre innholdet i den meldingen som
programmet skal skrive ut til brukeren etter at alle sammenlikningene er utført.
Java-fila som er gjengitt nedenfor kan du laste
ned ved å klikke på følgende link:
Sammenlikning.java.
1 import javax.swing.JOptionPane; 2 3 public class Sammenlikning 4 { 5 public static void main( String args[] ) 6 { 7 String førsteSifferstreng; // brukes ved innlesing 8 String andreSifferstreng; // brukes ved innlesing 9 String resultat; // tekststreng som brukes til utskrift 10 11 int førstetall; // første tall som skal sammenliknes 12 int andretall; // andre tall som skal sammenliknes 13 14 førsteSifferstreng = 15 JOptionPane.showInputDialog( "Skriv første heltall:" ); 16 17 andreSifferstreng = 18 JOptionPane.showInputDialog( "Skriv andre heltall:" ); 19 20 // konverterer sifferstrenger til heltallsverdier 21 førstetall = Integer.parseInt( førsteSifferstreng ); 22 andretall = Integer.parseInt( andreSifferstreng ); 23 24 // initialiserer utskriftsstrengen til en tom streng 25 resultat = ""; 26 27 if ( førstetall == andretall ) 28 resultat = resultat + førstetall + " == " + andretall; 29 30 if ( førstetall != andretall ) 31 resultat = resultat + førstetall + " != " + andretall; 32 33 if ( førstetall < andretall ) 34 resultat = resultat + "\n" + førstetall + " < " + andretall; 35 36 if ( førstetall > andretall ) 37 resultat = resultat + "\n" + førstetall + " > " + andretall; 38 39 if ( førstetall <= andretall ) 40 resultat = resultat + "\n" + førstetall + " <= " + andretall; 41 42 if ( førstetall >= andretall ) 43 resultat = resultat + "\n" + førstetall + " >= " + andretall; 44 45 // Viser resultat av sammenlikningene 46 JOptionPane.showMessageDialog( null, resultat, "Sammenlikningsresultater", 47 JOptionPane.INFORMATION_MESSAGE ); 48 } // slutt på main-metoden 49 } // slutt på klassen Sammenlikning
Her kan du se resultatet av å kjøre programmet med førstetall
lik -5 og andretall lik 3.
Nærmere forklaring til programkoden blir gitt nedenfor.
Test ut programmet ved at du laster ned java-fila, kompilerer og kjører programmet ved hjelp av TextPad. Prøv med forskjellige input-verdier og se hva du får ut. Prøv å skjønne hvorfor programkoden gir nettopp den utskriften som du får. Nedenfor kan du finne en nærmere forklaring på dette.
***
Vi skal se nærmere på enkelte detaljer i programkoden ovenfor.
Som i programeksempel 4, Addisjon, blir det lest inn to heltallsverdier fra
brukeren. Innlesingen skjer akkurat på samme måte som forrige gang.
I dette programmet skal de to tallene ikke adderes, men de skal sammenliknes for
likhet og størrelse (rekkefølge). Resultatene av sammenlikningene skal
skrives ut som melding til brukeren. Denne meldingen skal bare inneholde
sanne utsagn. For å avgjøre hva som skal stå i
utskriften, er det nødvendig å foreta noen sammenlikninger. Utfallet av disse
blir brukt som betingelser i if-setninger
som avgjør hva som skal tilføyes til utskriften. Alle
if-setningene har samme struktur. Vi ser
nærmere på den første av dem:
if ( førstetall == andretall ) resultat = resultat + førstetall + " == " + andretall;
Når denne koden blir utført, er det først betingelsen for
if-setningen:
førstetall == andretall
som blir utført. Operatoren == vil sjekke
om variablene førstetall og
andretall har samme verdi. Dersom det er
tilfelle, vil operatoren returnere true.
I motsatt fall vil den returnere false.
Instruksjonen
resultat = resultat + førstetall + " == " + andretall;
vil bare bli utført dersom operatoren ==
returnerer true. Vi ser at denne instruksjonen
er en tilordningsinstruksjon. Derfor er det høyre side i denne:
resultat + førstetall + " == " + andretall
som vil bli utført først. Ved første øyekast kan det her se ut som det
skal foretas en sammenlikning, siden vi finner operatoren
==. Men her står denne operatoren mellom
dobbelte sitattegn: " == ". Det dreier seg
derfor om en tekst, det vil si datatypen String.
Av de andre leddene som inngår i dette uttrykket som er satt sammen ved hjelp
av operatoren +, er
resultat av type
String, mens
førstetall og
andretall er av type
int. Siden det i uttrykket finnes
(minst) et ledd av type String, vil også de
andre leddene automatisk bli konvertert til type
String
(dersom de ikke allerede er av denne typen), og det hele blir skjøtt sammen til
én sammenhengende tekststreng. Generelt gjelder at en variabel kan
ikke brukes i et uttrykk før den har fått tilordnet en verdi. I dette
tilfelle har variablene førstetall og
andretall fått verdi via innlesing fra
brukeren. Variabelen resultat har derimot ikke
fått noen verdi fra brukeren. Derfor var det nødvendig å initialisere den
(det vil si gi den en startverdi) på annen måte. Det skjedde i instruksjonen
resultat = "";
som står rett foran if-setningen.
Legg merke til at i denne initialiseringen er det ikke skrevet noe tegn mellom
de doble sitattegnene "", heller ikke noe mellomrom. Variabelen
resultat er derfor blitt initialisert til det vi kaller en tom
streng, altså en tekststreng uten noe innhold. Det kan kanskje høres litt rart
ut at dette er nødvendig, men foreløpig må du bare godta at slik er det.
Først seinere, når du har lært mer om java-språket, vil du ha grunnlag for å
forstå at initialiseringen er nødvendig.
Når høyre side av tilordningsinstruksjonen
resultat = resultat + førstetall + " == " + andretall;
er blitt utført, blir resultatet tilordnet som ny verdi til
variabelen resultat som står på venstre side av
tilordningsinstruksjonen. Vi ser at alle
instruksjonene som inngår i if-setningene er
av formen
resultat = resultat + /* her kommer en ny tekststreng */;
(Tekst som står mellom /* og
*/ er en forklarende kommentar.) Resultatet er
at vi skjøter til ny tekst til den teksten som variabelen
resultat allerede inneholder.
Figur 4 viser resultatene av en kjøring av programmet med 7 og -13 som de
to innleste tallene. Vi ser at den andre, fjerde og sjette av
if-setningene her har 'slått til', slik at
vedkommende instruksjon er blitt utført. I de andre
if-setningene har testen gitt false,
slik at den tilhørende instruksjon ikke er blitt utført.
Figur 4
Lag en modifisert utgave av programmet Sammenlikning fra
Programeksempel 5 ovenfor. Programmet skal fortsatt lese inn to hele tall og
sammenlikne dem. Men programmet skal bare skrive ut hvilket tall som er minst,
eller eventuelt at de er like store.
Eksempler: Dersom tallene 13 og 7 leses inn, så skal programmet skrive ut
7 er minst.
Dersom -13 og 7 leses inn, så skal programmet skrive ut
-13 er minst.
(Det er altså det tallet som ligger lengst til venstre på tallinja som skal
skrives ut.)
Dersom 7 og 7 leses inn, så skal programmet skrive ut
Tallene er like store.
Lag et program som leser inn et helt tall og avgjør om tallet er delelig
med 3, det vil si om du får 0 som rest når du deler tallet med 3.
Utskriften fra programmet skal være tilsvarende som i følgende eksempler
(det som står i parentesene skal ikke være med i utskriften):
27 er delelig med 3
(tallet 27 er blitt lest inn).
32 er ikke delelig med 3
(tallet 32 er blitt lest inn).
Lag et program som leser inn tre hele tall fra brukeren. Programmet
skal finne ut hvilket av de tre tallene som er minst (det vil si ligger
lengst til venstre på tallinja) og skrive ut resultatet.
Eksempel: Dersom de tre innleste tallene er 5, -5 og 2, så skal programmet
skrive ut
-5 er minst.
Copyright © Kjetil Grønning og Eva Hadler Vihovde, revidert 2014