F3
f1pt
Val och loopar samt logiska uttryck
Läsanvisning: (kap 2, 4 och 5)
· Datatypen Boolean (2.3.4)
· Relationsuttryck och logiska uttryck (2.3.5-)
· De Morgan’s lag (p 56)
· operatorer (appendix C etc.)
· if
, switch (kap 4)
· for (kap 5),
· while
,
do-while
(kap 5)
· Kompilering och länkning
Nästa gång:
skall vi titta på hur man skriver metoder, hur
parameteröverföring funkar och hur man
hanterar vektorer (fält)
kap 6+7, vänta med 7.7-8
F3
1
Åter till vårt program
import java.util.Scanner;
public class Interest {
psv main(String[] args) {
// ##### read input #####
Scanner sc = new
Scanner(System.in);
... ngt utelämnat (inmatningen)
// felhantering av indata
// förutsätt indata ok TODO
// compute interest TODO: method
interest = interest/100 + 1;
double result = amount;
for (int i = 1; i<=years; i++) {
result = result * interest;
}
// ##### print result ######
// fix formating TODO
System.out.println(result);
// Sop(result)
}
}
F3
2
För att göra felhantering så behöver vi kunna
välja väg –
om ”allt ok” så
”gör jobbet”
annars
felutskrift
Kort syntax för if satsen
if (<boolean expression>) {
<statements1>
} else {
<statements2>
}
Semantik
1. Villkoret <boolean expression> evalueras.
2. Om det är sant
så utförs <statements1>
annars utförs <statement2>
( evalueras = beräknas)
Men vad är ett booleskt uttryck?
F3
3
Datatypen Boolean och logiska uttryck
Utsagan: ”Det snöar” eller ”a<8”
är antingen sann eller falsk
Att ta reda på vilket är en form av beräkning
som resulterar i något av värdena
”sant” eller ”falskt”
Typen boolean har litteralerna {true, false}
och de logiska (booleska) operatorerna
”and” (&&) , ”or” (||) och ”not” (!)
Relationsuttryck och logiska uttryck
Relationsuttryck: a<10, a!=10, a<=10-b
Logiska uttryck byggs upp av variabler av
typ boolean, relationsuttryck och de logiska
operatorerna and (&&), or (||) och not (!)
x>10 && x<20-y || b
10<x<20 GÅR DOCK EJ, varför?
10<x && x<20
(uttryck=expression)
F3
4
Sanningstabell för de logiska
operatorerna
A
TRUE
TRUE
FALSE
FALSE
B
TRUE
FALSE
TRUE
FALSE
not B
FALSE
TRUE
FALSE
TRUE
A and B
TRUE
FALSE
FALSE
FALSE
A or B
TRUE
TRUE
TRUE
FALSE
A xor B
FALSE
TRUE
TRUE
FALSE
boolean dead, sick, alive;
float temp;
.....
alive = true;
dead = !alive;
sick = alive &&
!(temp < 35.0 || temp > 42.0);
nåja...
Överkurs:
operatorn för xor är “^”
Java har även ett antal operatorer till för att
manupulera på bit-nivå tex &, |, >>, ...
F3
5
Förenkling av logiska uttryck:
De Morgan’s lag
!(A && B) är samma sak som !A || !B
!(A || B) är samma sak som !A && !B
Enkelt ex:
Betrakta uttrycket på förra sidan
!( temp < 37.0 || temp > 42.0 )
är då detsamma som
!(temp < 37.0) && !(temp > 42.0)
vilket i sin tur är
temp >= 37.0 && temp <= 42.0
Logiska uttryck evalueras med “lat”
evaluering
F3
6
De flesta operatorer i Java i
precedensordning
högsta
arg++, arg--, [],
(), metod anrop:
name.fieldname
unära
++arg, --arg, +arg,
-arg, !arg
new, (type)expr
multiplikationsop.
*, /, %
additionsop.
+, -
relationsop.
<, <=, >, >=,
instance of
likhetsop.
==, !=
tilldelning
=, +=, -=, .....
logiskt och
&&
logiskt eller
||
Prioriteten kan ändras med parenteser
(definieras olika i olika språk jmf Pascal:
[not] [*, /, div, mod, and] [+, -, or] [=, <, >, <= .....])
Ada:
[abs, not, **] [*, /, mod] [monadiska +,-]
[+, -, &] [=, /=, <, <=, >, >= ] [and, or, xor]
F3
7
if (<boolean expression>) {
<statements1>
} else {
<statements2>
}
// simple error handling of input
if (amount<=0
|| interest<0
|| years<1) {
System.out.println(
" One of amount<=0,
interst<0,
year<1 ");
// System.exit(); // ibland
} else {
// compute interest
// TODO: method
interest = interest/100 + 1;
double result = amount;
for(int i=1; i<=years; i++) {
result = result * interest;
}
// print result,
// fix formating TODO
System.out.println(result);
}
F3
8
Selektion - val: if satsen
Syntax
if (<boolean expression1>) {
<statements>
} else if (<boolean expression2>){
<statements>
} else if ( …
} else {
<statements>
}
Semantik
3.Villkoret(n) evalueras (i tur och ordning).
4.Satserna efter det första sanna villkoret
exekveras en gång.
5.Resten av villkoren evalueras inte.
6.Om inget av villkoren är sant exekveras
satserna efter else en gång.
· Noll eller ett else,
· Noll eller flera else if tillåtna.
( evalueras = beräknas)
F3
9
OBS Använd alltid block ( dvs { } )
Annars luras du med indenteringen
if (false)
System.out.println(“one”);
System.out.println(“two”);
System.out.println(“three”);
Vad skrivs ut?
if (false) {
System.out.println(“one”);
System.out.println(“two”);
}
System.out.println(“three”);
F3
10
Nästlade if - Exempel: Skottår=
om året är delbart med 4 om det är delbart med 100 om det är delbart med 400 => skottår
annars inte
om det inte är delbart med 100 => skottår
om året inte är delbart med 4 => ej skottår
if (year%4 == 0) {
if (year%100 == 0) {
if (year%400 == 0) {
return true;
} else {
return false;
}
} else {
return true;
}
} else {
return false;
}
Röda koden kan förenklas...
F3
11
if (year%4 == 0) {
if (year%100 == 0) {
return (year%400 == 0);
} else {
return true;
}
} else {
return false;
}
//====================================
if (year%4 == 0) {
return !(year%100 == 0) || (year%400 == 0);
} else {
return false;
}
//==================================
return ( (year % 4 == 0) &&
(!(year % 100 == 0) || (year % 400 == 0)) );
F3
12
Loopar med känt antal varv for-satsen
for (int i=0; i<=8; i=i+1) {
System.out.print(i + “ “);
} // end loop
// 0 1 2 3 4 5 6 7 8 (på en rad)
----------------------for (char ch='a'; ch<='z'; ch++) {
System.out.println(ch);
}
// a b c .... z med en per rad
-----------------------for(int tal=1; tal<=50; tal=2*tal){
System.out.println(tal);
}
// tal blir 1, 2, 4, 8, 16, 32
“Keep it simple”
F3
13
Loopar med okänt antal varv=while
Blocket utförs noll eller flera gånger.
Syntax
while (<boolean expression>) {
<statements>
}
Informell Semantik
1. Loopvillkoret (boolean expression) evalueras.
2. Om det är sant exekveras satserna inuti
loopen (<statements>) en gång varefter 1-2
utförs igen.
3. Om villkoret är falskt görs ingenting dvs
loopen terminerar (stannar).
int i = 0;
int p = 4;
while (i < 10 && p > 2) {
satser ...
i = i+1;
} // end loop
viktigt att i eller p ändras så loopen
terminerar.
F3
14
En for loop är egentligen bara en while loop
och dom kan göra samma saker:
for (int i=0; i<=8; i=i+1) {
System.out.print(i + “ “);
} // end loop
int i = 0;
while( i<=8) {
System.out.print(i + “ “);
i=i+1
}
--------------------int i = 0;
int p = 4;
while (i < 10 && p > 2) {
System.out.println(i);
i = i+1; p=i+2;
} // end loop
for(int i = 0, p = 4;
i < 10 && p > 2;
i = i+1, p=i+2) {
System.out.println(i);
} // but keep for simple!!!!!!!!
F3
15
De vanligaste felen med loopar är
”oändliga” loopar och “off-by-one” fel dvs att
man snurrar ett varv för mycket eller för lite
(pseudo-) oändlig loop:
int i = 0;
while (i < 10) {
satser ...
i = i-1;
}
För att komma ur en oändlig loop skriv: ^C
dvs control-C, håll in tangenten ctrl och C
När använder man vad? - generella tips:
for: Loopar med känt antal varv
”keep it simple” - det bör vara nåt i stil med
for (int i=0, i<10; i++) ....
använd annars en while
while: Loopar med okänt antal varv
noll eller flera varv
do-while: Loopar med okänt antal varv
ett eller flera varv (ovanligt! - undvik)
F3
16
De viktigaste satserna är avklarade
Ett program byggs huvudsakligen upp av
deklarationer och satser
Enkla satser
(enkla satser avslutas med ";")
· Tilldelning
· Metodanrop
· break
(av void metoder)
("Kortslutning" av loop/switch sats)
· return <uttryck>
(För att avsluta underprogram eller ge
resultat från funktioner)
·;
(Gör ingenting !)
Sammansatta satser
(avslutas INTE med ";" utom do-while )
· Villkorsats (if)
· Flervalsats (switch)
· Iterationssatser (for, while och do-while)
· Blocksats ( {satser} )
F3
17
F3
18
Kompilering och länkning
1. Från anteckningarna skapas en sk källtext med hjälp av ett
editeringsprogram tex emacs. Källtexten utgör den för oss läsbara
beskrivningen av det vi vill att programmet skall göra. Program,
programtext och källprogram är andra benämningar på källtext.
Vanligen slutar källtextens namn på något som avslöjar vilket språk
som använts, tex .ada, .java, .c (C), .p (Pascal), .asm (assembler) osv.
2. Källtexten kan vi ge som indata till en kompilator. En kompilator
översätter, den för oss begripliga men för datorn obegripliga, texten till
”maskinkod” som datorn ”förstår”. Detta kallas alltså kompilering. I
Javas fall så översätts källtexten till en mellanform, ett slags
maskinspråk för alla datorer, som kallas bytekod. Kompilatorn
analyserar också texten och kontrollerar om programmet vi skrivit är
ett språkligt korrekt program. Om det tex förekommer syntaxfel eller
typfel i källtexten så meddelar kompilatorn detta och stannar.
3. Som resultat av kompileringen får vi ett program som innehåller de
genererade bytekodinstruktionerna. Detta lagras i en fil som heter
samma som källtexten men med appendix “.class”.
4. Varje dator har sedan en “bytekod interpreter” som som översätter
till den aktuella datorns maskinkod. Detta program är på
maskinkodsform men alla referenser (adresser) är inte upplösta
(kända). Det innebär att vissa andra programmoduler (som tex
java.lang) inte är kända ännu eftersom de kompilerats separat.
5. Nästa steg är att kalla på länkaren som bestämmer var
instruktionerna skall ligga i minnet och fyller i alla referenser mellan
modulerna. Om vi länkar ihop våra objektprogram och andra
referenser så får vi ett exekverbart program, ett laddprogram.
6. Ett laddprogram är färdigt att ”ladda” in i datorn för att köras. I detta
program är alla referenser upplösta.
7. När vi exekverar programmet får vi eventuellt förse det med indata
och får (eventuellt) ett resultat (utdata). Vi kan exekvera programmet
genom att ge namnet på källtextfilen utan appendix.
Dessa faser måste dessutom gås igenom varje gång man ändrar något i
källtexten
F3
19
Indentering och att placera ‘{ }‘
if (tal%2 == 0) {
return false;
} else {
return true;
}
------------------------------if (tal%2 == 0)
{
return false;
}
else
{
return true;
}
Mitt (och skaparna av Javas) råd:
Undvik tomrum
Indentering = läsbarhet+korrekthetskoll
F3
20
Bägge ovan gör samma sak som
if (tal%2 == 0) {return false;}
else {return true;}
dvs allt på en rad
När man lärt sig booleaner ordentligt så
skriver man alltid detta så här:
return (tal%2 != 0)
dvs if satsen
if (tal%2 == 0) {
return false;
} else {
return true;
}
är ekvivalent med
return (tal%2 != 0)
F3
21
Kommentarer
Tre sorters kommentarer i Java
// allt till slutet av raden
/*
allt som står mellan
*/
/* allt som står mellan*/
/**
********** ********** **********
•
Javadoc kommentarer
•
allt som står mellan
********** ********** **********
*/
F3
22
Bra/dåliga kommentarer
Skall tillföra något, förklara svåra saker
- Underkommentera inte
- Överkommentera inte
Dåliga kommentarer:
Tillför ingen information:
int i = 0;
// deklarera en räknare
i = i+1;
// öka i med ett
System.out.println(); // Tomrad
Man kan däremot tala om vad man skall
använda räknaren ”i” till (men ännu bättre är
kanske att hitta ett bättre namn) och man
kan tala om varför man ökar i.
Bra kommentarer:
// vi ökar med 2 för att bara få med udda tal
i = i+2;
// Checks if s matches (a and b are ints)
// "a/b", "-a/b", "a/-b", "(-)a"
if(!s.matches("-?\\d+/\\d+|\\d+/-?\\d+|-?\\d+")){
F3
23
Mer om Scanner
Klassen java.util.Scanner förser oss med
inmatningsprimitiver så vi kan läsa “tokens”
från tangentbordet:
(en token kan tex vara ett tal eller en
sträng)
import java.util.Scanner;
...
Scanner in = new Scanner(System.in);
while(in.hasNext()) {
String str = in.next();
System.out.println(str);
}
Metoder i Scanner:
(ersätt X med Int, Double, ..., eller inget)
in.hasNext() finns det någonting
in.next() ger nästa token som sträng
in.nextLine() ger hela raden som en sträng
in.hasNextX() finns det ett X
in.nextX() ger nästa X
F3
24
3 goda råd:
- Du behöver “plugga” glosor
Gör dig en ordlista
programspråk, syntax, semantik,
Abstraktion, modularisering, composition,
objektorientering, datatyper, kontrollstrukturer,
metoder, procedurer, funktioner, black box,
interface, gränssnitt,
identifierare (namn på saker), litteraler (konstanta
värden), konstanter, typer, variabler och
tilldelning
primitiva typer och klasstyper, referenstyper,
sammansatta typer,
...
- Läs boken!
Du behöver läsa sådär 100 sidor per vecka. Du
fixar inte det på söndag kväll...
Och lös många uppgifter...
- Du måste programmera.
F3
25
