1
Central-enhet
BIOS
PM
CPU
Skivminne
Sekundärminnesenheter
(SM)
CD-läsare
Diskett-läsare
Stefan Möller
2
Primär-minne (PM)
Processor (CPU)
0
11001010 00101101 10101100 10101101
4
00101101 10101100 10101101 10101010
R1
8
10101011 01101101 10011100 11010011
R2
12
00101101 10101100 10101101 11010001
16
11001010 00101101 10101100 10101101
20
01011100 01111001 00110100 11101001
24
10011100 10101011 10101100 10101101
28
11001010 00101101 10101100 01110001
Ett antal register ...
Styrenhet
Aritmetisk
enhet
Vektor av minnesceller
8 bitar = 1 byte, 4 byte = 1 ord
t ex 256 MB (megabyte - miljoner byte)
program-instruktioner & -data
Stefan Möller
3
Olika nivåer av program
Maskinkod (binär kod)
Ett antal (t ex 32) ettor/nollor
100111001001111100011010
Krångligt att skriva direkt
Assemblerkod
Mnemoniska namn för instruktioner
Add #25 to R3
Ett-till-ett matchning mot maskinkod
Olika instruktioner beroende på dator
Högnivåspråk
Mer kraftfulla instruktioner
if (x!=5) x+=10;
Ger 5-10 maskininstruktioner
Ej beroende av datorsystem
T ex Pascal, C, C++, Java
Stefan Möller
4
Kod i högnivåspråk måste översättas till maskinkod.
Kompilering:
Källkod i
högnivåspråk
Kompilator
Olika beroende
på datorsystem
Maskinkod som
kan exekveras i
datorsystemet
Interpretering:
Källkod i
högnivåspråk
Interpretator
Olika beroende på datorsystem
Läser en instruktion i taget, översätter
till maskinkod och exekverar
Stefan Möller
5
Programmering
Indata
Program
Utdata
Data kan vara av olika typ:
12
43
73.67
true
”Kalle Nilsson”
’X’
730512
”Stockholm”
Bil:
Volvo
ABC 123
Röd
7300 mil
Måste representeras i programmet.
Stefan Möller
6
Javas Primitiva Datatyper
Heltalstyper:
byte
short
int
long
8 bitar
16 bitar
32 bitar
64 bitar
Flyttalstyper:
float
double
32 bitar
64 bitar
Övriga:
char
boolean
Unicode 16 bitar
true / false
Textsträngar (INTE primitiv datatyp):
String
Stefan Möller
7
Litteraler
Deklaration
Tilldelning
Utskrift
Inläsning
Selection
Iteration
Stefan Möller
if-satsen
if (<villkor>)
<programsats>;
if (<villkor>)
<programsats1>;
else
<programsats2>;
Nästlade if-satser
8
int x=8;
if (x>5)
System.out.println(x);
if (x<10)
x++;
else
x--;
//Kan även skrivas så här:
if (x<10) x++; else x--;
if (x>25)
if (x<50)
System.out.println(”Mellan 25 och 50”);
else
System.out.println(”50 eller större”);
else
System.out.println(”25 eller mindre”);
Stefan Möller
9
Villkor (booleska uttryck)
Jämförelse-operatorer:
< <= >
(operanderna enkla datatyper)
>=
==
!=
Logiska operatorer:
&& ||
!
(fullständigt utvärderande: & | )
String’ar jämförs INTE med dessa operatorer.
String s1=”Hej”, s2=”Hopp”;
if ( s1.equals(s2) ) ... ;
//equals returnerar true om INNEHÅLLET i s1 och s2 är lika
int x = s1.compareTo(s2);
//compareTo returnerar ett positivt tal om s1 > s2
//ett negativt tal om s1 < s2 samt 0 om s1 = s2
Stefan Möller
10
switch-satsen
switch (<uttryck>) {
case <värde>:
<programsatser>
case <värde>:
<programsatser>
default:
<programsatser>
}
”Hoppar” till den case som
matchar uttrycket. Exekverar
resten av programsatserna.
break-satsen bryter switch
break;
(kan även användas på loopar)
Uttryck och värde måste vara av
heltalstyp eller char
int x, tal=10;
//x får ett slumpvärde
switch(x){
case 1:
System.out.println(tal);
case 2: case 3:
System.out.println(++tal);
case 4:
System.out.println(tal++);
default:
System.out.println(tal);
}
Stefan Möller
11
while - loopen
while (<villkor>)
<programsats>;
<villkor> - booleskt uttryck
<programsats> - valfri programsats
om flera satser inom { } - block
do
break;
continue;
<programsats>;
while (<villkor>);
false
villkor
//bryter loopen
//börja om nästa varv
sats
true
villkor
sats
true
false
Stefan Möller
12
for-loopen
for (<initiering> ; <villkor> ; <uppräkning>)
<programsats>;
initiering
Skriv ut talen 1 - 10:
for (int x=1; x<=10; x++)
System.out.println(x);
false
villkor
true
Man kan utelämna någon del:
programsats
int x=1;
for ( ; x<=10; x++)
System.out.println(x);
uppräkning
for (int y=1; y<=10; )
System.out.println(y++);
Stefan Möller
Skriv en programsnutt som skriver ut en tabell över
celsius-temperaturer & motsvarande fahrenheit-temperaturer
var 10’de celsius i intevallat 10-90:
Förväntat utseende:
Celsius Fahrenheit
----------------------10
50
20
68
30
86
40
104
50
122
60
140
70
158
80
176
90
194
System.out.println("Celsius Fahrenheit");
System.out.println("-----------------------");
for (int cels=10; cels<100; cels+=10){
int fahr=(int)(9.0/5.0*cels+32);
System.out.println("
"+cels+"
"+fahr);
}
Stefan Möller
13
14
Operatorer
Prioritetsordning
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Operatorer
[] . (metod anrop) ++ -++ -- + - ~ !
new (cast)
* / %
+ << >> >>>
< <= > >=
instanceof
== !=
&
^
|
&&
||
?:
Stefan Möller
= += -= *= /= %=
15
Flera variabler av samma sort - arrayer
Varje variabel som deklareras får ett utrymme i primärminnet.
int tal;
double d;
tal=43;
d=7.85;
tal
43
7.85
d
En array deklareras som <typ>[ ]
int[] arr;
arr
Utrymmet måste skapas, görs med new
arr = new int[5];
arr[0]=28;
arr
28
arr[1]=43;
0
arr[2]=12;
arr[3]=19;
arr[4]=193;
(inget utrymme finns...)
43
12
19
193
1
2
3
4
Stefan Möller
16
Array
Deklaration:
int[] arr;
int arr[];
//Alternativ deklarering
Skapas med new
arr=new int[25];
//Alltid index från 0 och uppåt
Indexering med [<index>]
arr[3]=12;
Längden kan kollas med length
int max=arr.length;
//max får värdet 25
Initiering vid deklaration
int[] kvadrater={0, 1, 4, 9, 16, 25, 36};
Stefan Möller
17
Om vi vill representera mer komplexa objekt?
T ex bilar som har ett bilmärke, ett registreringsnummer, en färg samt
en mätarställning.
Volvo
ABC 123
Röd
7300
Saab
XYW 987
Vit
3800
Fiat
MSQ 545
Svart
12900
Att ”samla ihop” flera attribut på detta sätt görs i klasser.
Vi behöver alltså nu en klass Bil som skall ha attributen
märke, regnummer, färg och mätarställning.
Klasser kan innehålla mer än attribut, exempelvis konstruktorer och
metoder.
Stefan Möller
18
Deklaration av klass Bil:
class Bil{
String märke, regnummer, färg;
int mätarställning;
}
Varje klass läggs lämpligen i en egen fil. Denna Bil-klass läggs
alltså då på filen Bil.java
Skapa objekt
Referenser
Åtkomst
null
Stefan Möller
19
class - deklaration
class <class-namn>{
Olika data som beskriver
klassen, t ex märke, mätarställning
hos en Bil
<variabel-deklarationer>
<konstruktorer>
Anropas när ett objekt av klassen
skapas (med new <classnamn>)
<metoder>
<class-deklarationer>
}
Olika operationer som kan
göras på klassen
En klass kan ha ”inre” klasser
Stefan Möller
20
Metoder - subrutiner
<modifierare> <returtyp> <namn> (<argumentlista>){
<lokala deklarationer och programsatser>;
}
modifierare anger olika egenskaper, t ex för åtkomst
public, private, protected, abstract, static, final, native, synchronized
returtyp vad som returneras. Valfri datatyp, även referenser till classer eller arrayer.
argumentlista lista över eventuella indata till metoden. Om inga argument ( ).
int getInt(){...}
static void skriv(int x, int y, String str){...}
Java ”letar upp” och startar metoden main vid programmets start:
public static void main(String[] args){...}
Stefan Möller
21
Argumentöverföring
Retur-värde
Överlagring
klass-metoder
instans-metoder
Stefan Möller
22
Slumptal - biblioteks-klassen Random
Det finns ett antal fördefinierade klasser i Java’s API-bibliotek.
Beskrivs i API-dokumentationen:
http://java.sun.com/j2se/1.5.0/docs/api/
Klassen Random används om man vill ha slumptal. Random ligger i
java.util - delbiblioteket.
Innehåller metoder för att få slumptal, t ex:
int nextInt()
int nextInt(int n)
boolean nextBoolean()
double nextDouble()
returnerar ett slumpmässigt heltal
returnerar ett slumptal mellan 0 och n-1
(nextInt(100) returnerar alltså ett tal mellan 0 och 99)
returnerar true eller false
returnerar ett tal mellan 0.0 och 1.0
Stefan Möller
Ett program som skriver ut 10 slumptal mellan 1 och 100:
import java.util.*;
class SlumpTest{
public static void main(String[] args){
Random slump = new Random();
for (int x=1; x<=10; x++){
int tal = slump.nextInt(100) + 1;
System.out.println(tal);
}
}
}
import-satsen kan utelämnas. Man måste då skriva:
java.util.Random slump = new java.util.Random();
Man kan skriva:
import java.util.Random;
Stefan Möller
23
24
Klassen Math
Ligger på java.lang - delbiblioteket.
Allt som ligger i java.lang kan användas direkt, man behöver alltså INTE
göra: import java.lang.*;
I Math-klassen finns ett antal statiska metoder och variabler, t ex
static double PI
pi med jättemånga decimaler...
static int abs(int a)
returnerar absolutbeloppet av a
static double log(double a)
returnerar naturliga logaritmen av a
static double pow(double a, double b)
returnerar a upphöjt till b
plus många fler... Eftersom metoderna är statiska så kan de anropas utan
att man skapar ett Math-objekt:
double dd = Math.sqrt(14);
double omkrets = Math.PI * diameter;
Stefan Möller
25
Jämförelse av anrop på metoder i Random och Math:
Random slump = new Random();
int tal = slump.nextInt(100);
double d = 4.876;
int x = (int)Math.round(d);
nextInt är en instansmetod. Man måste alltså
skapa ett Random-objekt
innan nextInt kan anropas
round är en klassmetod.
static long round(double d);
Kan alltså anropas via
klassnamnet
Stefan Möller
