Programmering i språket C++

LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
PROGRAMMERING I SPRÅKET JAVA
Innehåll
0. EXEMPEL OCH ÖVNINGAR TILL JAVA-JAVISST! ..................................................................................... 4
0. OM PROGRAMUTVECKLING (P1) ............................................................................................................................ 4
1. ECLIPSE & GRUNDLÄGGANDE PROGRAMMERING (P1) ........................................................................................... 5
Heltal och utmatning ............................................................................................................................................. 5
Inmatning av heltal ............................................................................................................................................... 6
Inmatning av decimaltal........................................................................................................................................ 8
Urval och selektion med if och else ....................................................................................................................... 8
Teckentypen char .................................................................................................................................................. 9
Textsträngtypen String ........................................................................................................................................ 10
Iteration med while-loop ..................................................................................................................................... 10
Specialecken ........................................................................................................................................................ 12
2. KLASSER OCH OBJEKT (P1 OCH P2) ...................................................................................................................... 13
Åtkomst och inkapsling ....................................................................................................................................... 13
Klassvariabler och fält av klasser ....................................................................................................................... 16
Klassmetoder och final........................................................................................................................................ 17
3. ARV (P2) .............................................................................................................................................................. 18
Skapa klasser genom arv ..................................................................................................................................... 18
Sammanfattning av arvbegrepp .......................................................................................................................... 20
Metoden toString() .............................................................................................................................................. 21
Egna paket .......................................................................................................................................................... 22
4. GUI-PROGRAM MED SWING (P1, P2) ................................................................................................................... 24
Frame-objekt ....................................................................................................................................................... 24
Textklassen JLabel .............................................................................................................................................. 24
Knappobjektet JButton och händelser................................................................................................................ 26
Textfältet JTextField ........................................................................................................................................... 27
Aritmetik, cast och typomvandling ...................................................................................................................... 28
ASCII-standard och Unicode .............................................................................................................................. 30
Klassen Math ...................................................................................................................................................... 31
Felhantering med try-catch ................................................................................................................................. 32
Avrundning och utskriftsformatering .................................................................................................................. 33
5. GRAFIK, BILDER OCH LJUD (P2) ........................................................................................................................... 34
Klassen JPanel .................................................................................................................................................... 34
JPanel som rityta ................................................................................................................................................ 34
Färger, text och figurer ....................................................................................................................................... 35
Visa bilder ........................................................................................................................................................... 35
Rekursion ............................................................................................................................................................ 36
Grafik med rekursion .......................................................................................................................................... 38
Cantor-mängden ................................................................................................................................................. 39
Koch-kurvan ........................................................................................................................................................ 40
Ormbunksblad ..................................................................................................................................................... 41
Mandelbrotmängden ........................................................................................................................................... 42
Fullskärmsläge .................................................................................................................................................... 43
Ljud ..................................................................................................................................................................... 44
Egna grafiska klassen Cirkel .............................................................................................................................. 45
Lite om animering och tangenthändelser ............................................................................................................ 47
Förslag på repetitionsuppgifter inför prov 2 i Programmering C (P2) .............................................................. 49
7. MEST OM LOOPAR OCH VAL (P1).......................................................................................................................... 50
Nästlade if-satser ................................................................................................................................................ 50
Jämförelseoperatorer och logiska operatorer .................................................................................................... 51
Sammansatta villkor ............................................................................................................................................ 51
Urval med Switch ................................................................................................................................................ 53
Loopar ................................................................................................................................................................. 53
Datatypen boolean .............................................................................................................................................. 55
9. ARRAYER, SORTERING OCH STRÄNGAR ................................................................................................................ 57
ARRAY ..................................................................................................................................................................... 57
875099958
1
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
SORTERING .............................................................................................................................................................. 61
MER OM STRÄNGAR ................................................................................................................................................. 62
13. ANIMERING OCH TRÅDAR ................................................................................................................................... 63
Timer ................................................................................................................................................................... 63
Klasser och Timer ............................................................................................................................................... 66
Datorns tid .......................................................................................................................................................... 68
Grafik och animering .......................................................................................................................................... 69
Mushändelser ...................................................................................................................................................... 71
18. APPAR FÖR ANDROID ......................................................................................................................................... 73
Installation av verktyg ......................................................................................................................................... 73
Androidprojekt .................................................................................................................................................... 74
TextView, typsnitt, färger och bakgrundsbild ..................................................................................................... 75
Händelsehantering – via ett exempel .................................................................................................................. 76
Beräkningar och layout ....................................................................................................................................... 78
Radio- och bildknappar....................................................................................................................................... 79
Layouter .............................................................................................................................................................. 80
Grafik .................................................................................................................................................................. 82
Animering ............................................................................................................................................................ 84
Bilderväxlingar ImageViews ............................................................................................................................... 84
Menyer ................................................................................................................................................................ 85
Ändra startsida .................................................................................................................................................... 86
Ljud ..................................................................................................................................................................... 86
Gruppuppgift – turistapp..................................................................................................................................... 87
Publicera appar på Google Play ........................................................................................................................ 88
1. VI BÖRJAR PROGRAMMERA......................................................................................................................... 89
INLEDNING ............................................................................................................................................................... 89
NEDLADDNING OCH INSTALLATION AV JAVA........................................................................................................... 89
JAVA MED TEXTPAD ................................................................................................................................................ 90
JAVADOKUMENTATION ............................................................................................................................................ 90
FÖRSTA PROGRAMMET I JAVA - UTMATNING ........................................................................................................... 91
INMATNING MED STANDARDKLASSER ...................................................................................................................... 92
String och tecken ................................................................................................................................................. 92
Heltal och decimaltal .......................................................................................................................................... 93
AVRUNDNING .......................................................................................................................................................... 93
HELTALSDIVISION .................................................................................................................................................... 93
ASCII-KOD .............................................................................................................................................................. 93
MATEMATISKA FUNKTIONER ................................................................................................................................... 94
URVAL OCH LOOPAR ................................................................................................................................................ 94
FÄLT (ARRAY) ......................................................................................................................................................... 95
2. GRAFISKA METODER ...................................................................................................................................... 98
FÖNSTER (FRAME) ................................................................................................................................................... 98
FÄRGER ................................................................................................................................................................... 98
LINJE I FÖNSTER MED METODEN PAINT .................................................................................................................... 99
TEXT I FÖNSTER ..................................................................................................................................................... 100
INSTANSVARIABLER MED KONSTRUKTOR OCH OBJEKT .......................................................................................... 103
INLÄSNING AV VARIABLER..................................................................................................................................... 104
3. APPLETS OCH GRAFISKA KOMPONENTER ............................................................................................ 106
APPLETS ................................................................................................................................................................ 106
PARAMETRAR I HTML-KODEN .............................................................................................................................. 109
GRAFISKA KOMPONENTER ..................................................................................................................................... 110
Knapp ................................................................................................................................................................ 110
Textruta ............................................................................................................................................................. 111
Etikett (label)..................................................................................................................................................... 112
Egenskaper hos komponenter ........................................................................................................................... 113
Rullningslist (scrollbar) .................................................................................................................................... 114
4. MUS- OCH TANGENTHÄNDELSER ............................................................................................................. 116
MUSHÄNDELSER .................................................................................................................................................... 116
875099958
2
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
OVERRIDE PÅ UPDATE ............................................................................................................................................ 117
RITA UTAN PAINT ................................................................................................................................................... 119
TANGENTHÄNDELSER ............................................................................................................................................ 120
5. ANIMERING MED TRÅDAR .......................................................................................................................... 121
TRÅDAR OCH MULTITASKING................................................................................................................................. 121
MULTIPELT ARV OCH GRÄNSSNITT I JAVA ............................................................................................................. 121
KLASSEN THREAD OCH GRÄNSSNITTET RUNNABLE ............................................................................................... 121
TVÅ TRÅDAR .......................................................................................................................................................... 124
TRÅDAR I EGEN KLASS ........................................................................................................................................... 125
6. KLASSER I EGNA FILER ................................................................................................................................ 127
EGEN KLASSFIL ...................................................................................................................................................... 127
LÖSNINGAR .......................................................................................................................................................... 128
875099958
3
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
0. Exempel och övningar till Java-javisst!
Kursmaterialet Java-javisst! omfattar det centrala innehållet till gymnasiekurserna
Programmering 1 och 2 (P1 och P2), samt den gamla kursen Programmering C. I detta kapitel
finns kompletterande exempel och övningar som anknyter till motsvarande kapitel i
kursmaterialet Java-javisst! På följande Youtubelänkar finns bra lektioner (tutorials)
i Java. Följande länk innehåller grunderna och denna fortsättningen, där kurs 20
inleder med Java Applets. Han som gjort detta heter thenewboston och har även
andra kurser.
0. Om programutveckling (P1)

Visar programmering av LEGO MINDSTORMS NXT,
http://mindstorms.lego.com/en-us/whatisnxt/default.aspx.

Laddar ner Java Plattforn (JDK) via
http://www.oracle.com/technetwork/java/javase/downloads
/index.html och installerar (se nedan).

Gör en mapp med namnet java på datorn, kopiera första
javakoden nedan (utskrifter), klistra in koden i
Anteckningar och spara filen under namnet test1.java
(samma namn som klassen) i mappen java.

Öppna Kommandotolken via tillbehör och gå till
mappen java (testa DOS-kommandona dir, cd
mappnamn och cd..).

Prova och kompilera filen med javac test1.java.
Fungerar inte!

Lägg in en sökväg (path) till bin-mappen där
programmet java.exe ligger (se nedan).

Kompilera test1.java igen, samt kör den kompilerade filen test1.class med kommandot java
test1.
Övning 0.0.1:
Skapa filen test001.java som skriver ut ditt förnamn och efternamn på samma rad. Kompilera
och kör programmet med kommandotolken.
Övning 0.0.2:
Modifiera föregående program så att för- och efternamn skrivs ut på olika rader.
875099958
4
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
1. Eclipse & Grundläggande programmering (P1)

Ladda ner programutvecklingsverktyget Eclipse via http://www.eclipse.org/downloads/.
Eclipse är ett s.k. IDE - Integrated Development Environment, som är kopplat till JDK och
förenklar programmeringen med felmeddelanden, kompileringen och körningen av
programmen jämfört med om det skulle ha gjorts via en vanlig texteditor (Anteckningar) och
med kommandotolken.

Genomgång av Eclipse (s. 3-4).
Övning 0.1.1:
Skapa javaprojektet kap1 med Eclipse i mappen C:\Users\User\Documents\java\. Byt så att
denna mappen blir till workspace med menyvalet File/Switch Workspace i Eclipseprogrammet.
Heltal och utmatning
Genomgång av utmatning och beräkning av heltal (s. 5-8). Ett programexempel:
public class Summera {
public static void main( String[] args ){
int x, y, sum;
x = 17;
y = 23;
sum = x + y;
System.out.println("Summan är " + sum); //Utskrift i konsoll
}
}
Heltalsvariabler har datatypen int (integer) och måste deklareras i ett program:
int kalle=3, x;
x=kalle; //x får värdet som variabeln kalle har, d.v.s. 3;
Observera att texten i programmet ovan är tabulerad (tabbad). Detta kallas indentering och görs
för att öka läsbarheten av programmet. Om programmet inte är indenterat gör detta automatiskt
med kommandor Ctrl+Shift+F.
Övning 0.1.2:
Skapa programmet Ovn012.java i projektet kap1. Programmet ska skriva ut följande tre
meningar med tre olika satser, antingen System.out.println eller System.out.print:
Jag heter Anders i förnamn.
Andersson i efternamn. Jag bor i Skoghall.
Övning 0.1.3:
Skapa programmet Ovn013.java i projektet kap1 som adderar de båda heltalen x och y, som har
värdena 3 respektive 7. Med koden:
System.out.println("x="+x);
System.out.println("y="+y);
System.out.println("Summan är="+x+y);
//koden har ett fel. Vilket?
Ska utskriften bli:
x=3
y=7
Summan är 10
875099958
5
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Övning 0.1.4:
Skapa programmet Ovn014.java i projektet kap1 som multiplicerar de båda heltalen x=5 och
y=7 och som tilldelar produkten till heltalsvariabeln prod med koden:
int x=5, y=7, prod;
prod=x*y;
Ska utskriften bli:
x=3
y=7
Produkten är 10
Inmatning av heltal
Genomgång av inmatning av text och heltal (s. 9-10). Ett programexempel:
import java.util.*; //paket för klassen Scanner
public class Summa{
public static void main(String[] args){
Scanner sc = new Scanner(System.in); //Scanner, klass för inmatning
int x, y, sum;
System.out.print("Skriv ett tal: ");
x = sc.nextInt(); //läser in heltal
System.out.print("Skriv ett tal till: ");
y = sc.nextInt();
sum = x + y;
System.out.println("Summan är " + sum);
}
}
Med utskriften:
Skriv ett tal: 3
Skriv ett tal till: 4
Summan är 7
Övning 0.1.5:
Skapa programmet Ovn015.java i projektet kap1 som beräknar din ålder med följande
utskrifter:
Vilket år är du född: 1959
Ange innevarande årtal: 2012
Du fyller 53 år i år.
Övning 0.1.6:
Skapa programmet Ovn016.java i projektet kap1 som beräknar hur långt (s meter) en sten faller
fritt på en viss tid (t sekunder) med formeln s = 4,9 ∙ t2. Det ska även gå att mata in decimaltal.
Utskrifterna är följande:
Ange tiden i sekunder som stenen faller fritt: 3
På 3 sekunder faller stenen 44.1 m
875099958
6
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Övning 0.1.7:
Skapa programmet Ovn017.java i projektet kap1 som läser in två heltal och beräknar talens
summa, differens, produkt och kvot, med följande utskrifter:
Ange två heltal: 15 3
Summan är: 18
Differensen är: 12
Produkten är: 45
Kvoten är: 5
875099958
7
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Inmatning av decimaltal
I förra uppgiften matade vi in heltal via konsollen. Datorn skiljer dock på heltal (int) och
decimaltal (double). Därför är metoderna för inmatning lite olika:
Scanner sc = new Scanner(System.in); //Scanner, klass för inmatning
int x;
//deklaration av heltalsvariabel
double y;
//deklaration av decimaltalsvariabel
x = sc.nextInt();
//läser in heltal
y = sc.nextDouble();
//läser in decimaltal
I Ingemar Olofssons dokument http://web.kristinehamn.se/skola/anders/java/JavaKurs.pdf kan
du läsa mer om datatyperna int och double.
Övning 0.1.8:
Modifiera övningarna 0.1.6 och 0.1.7 så att de även räknar med decimaltal.
Övning 0.1.9:
Skriv javaprogrammet ovn019.java som beräknar omkretsen L av en cirkel med formeln
L=2R, där R är cirkelns radie och ≈3,14. Utskrifterna ska vara följande:
Ange en radie: 4
Omkretsen= 25.12
Tänk på hur ett decimalkomma matas in (punkt eller komma) i konsolen, samt hur
decimalkomma skrivs i programkoden.
Urval och selektion med if och else
Genomgång av avsnittet Selektion (s. 13).
Övning 0.1.10:
Skriv ett program ovn0110.java som frågar efter din kroppstemperatur. Om febern är mer än
37,5 ska programmet skriva ut "FEBER!" annars ska programmet skriva ut "Du ar frisk!".
Övning 0.1.11:
Skriv ett program ovn0111.java som läser in två decimaltal. Om talen är lika skrivs Talen är
lika! ut, annars skrivs Talen är olika! ut.
Övning 0.1.12:
Skriv ett program ovn0112.java som läser in två tal och som sedan skriver ut det största av talen.
Om båda är lika skrivs också talet ut.
*Övning 0.1.13:
Skriv ett program ovn0113.java som läser in tre tal och som sedan skriver ut det största av talen.
875099958
8
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Teckentypen char
Teckenvariablerna t och s deklareras med satsen:
char t,s=’k’;
//char = character
Tecknet t läses in från tangentbordet med satsen:
t = sc.next().charAt(0);
//sc är som tidigare av klassen Scanner
Genomgång av avsnittet teckenvariabler (s. 14).
Övning 0.1.14:
Skriv programmet ovn0114.java som läser in två bokstäver. Om bokstäverna är lika skrivs
Bokstäverna är lika! ut, annars skrivs Bokstäverna är olika! ut. Bokstäverna ska matas in på
samma rad skilda åt av mellanslag, med utskriften:
Ange två bokstäver: e u
Bokstäverna är olika!
Övning 0.1.15:
Skriv programmet ovn0115.java som läser in en bokstav och som sedan kollar om tecknet
kommer före bokstaven h i alfabetet. Om exempelvis den inmatade bokstaven är d skrivs ”d
kommer först”, annars skrivs ”h kommer först”. Utskriften är följande:
Övning 0.1.16:
Skriv programmet ovn0116.java som först frågar om du vill beräkna en produkt (gånger) eller
kvot(delat), varpå du svarar med ett p eller k. Om du väljer p uppmanas du mata in två tal, varpå
produkten skrivs ut. Väljer du k uppmanas du först mata in täljaren och sedan nämnaren, varpå
kvoten skrivs ut. Utskrifterna är följande:
Vill du beräkna en produkt (p) eller kvot (k)? p
Mata in två tal: 4 5
Produkten är 20
Eller:
Vill du beräkna en produkt (p) eller kvot (k)? k
Mata in täljaren: 42
Mata in nämnaren: 7
Kvoten är 6
875099958
9
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Textsträngtypen String
En följd av tecken kallas för en textsträng eller bara sträng, exempelvis ”Java är kul” (s. 15).
Strängvariablerna namn och s deklareras med satsen:
String namn="Anders", s; //Stort S i String!
En strängvariabel läses in med följande två satser:
enamn = sc.next(); //sc är som tidigare av klassen Scanner. Läser ej blanktecken
enamn = sc.nextLine(); Läser även blanktecken
Datatyperna int, double och char är primitiva datatyper, medan String är en klass, vilket vi
läser mer om senare.
Övning 0.1.17:
Skriv programmet ovn0117.java som läser in ditt förnamn, efternamn och ålder och sedan
skriver ut detta, enligt utskrifterna nedan:
Ange förnamn: Kalle
Ange Efternamn: Ek
Ange ålder: 17
Du heter Kalle Ek och är 17 år
Övning 0.1.18:
Skriv programmet ovn0118.java som läser in en text och som sedan skriver ut texten med
följande utskrift:
Mata in en text: Java och matte är jättekul
Du matade in texten: Java och matte är jättekul
Iteration med while-loop
Ska något upprepas (itereras) görs detta med en loop (s. 16). Vi inleder med med while-loopen,
som avbryter när ett villkor är uppfyllt. Följande program visar hur ordet java skrivs ut 5 gånger:
public class test {
public static void main( String[] args ){
int i = 1;
while(i<=5){
System.out.println("Varv nummer "+i);
i=i+1; //i++ fungerar också
}
}
}
Med utskriften:
Varv
Varv
Varv
Varv
Varv
nummer
nummer
nummer
nummer
nummer
875099958
1
2
3
4
5
10
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Övning 0.1.19:
Skriv programmet ovn0119.java som skriver ut ditt namn 4 gånger på skärmen med en whileloop, med följande utskrift:
Anders Anders Anders Anders
Övning 0.1.20:
Modifiera föregående program så att det frågar efter och läder in hur många gånger ditt namn ska
skrivas ut, med följande utskrift:
Hur många gånger ska ditt namn skrivas ut? 8
Anders Anders Anders Anders Anders Anders Anders Anders
Övning 0.1.21:
Modifiera föregående program ytterligare så att det även frågar efter vad du heter, med följande
utskrift:
Vad heter du? Anders
Hur många gånger ska ditt namn skrivas ut? 8
Anders Anders Anders Anders Anders Anders Anders Anders
Övning 0.1.23:
Skriv programmet ovn0123.java som frågar efter hur långt uppräkning ska ske, med följande
utskrift:
Hur långt ska uppräkning? 8
1, 2, 3, 4, 5, 6, 7, 8
Övning 0.1.24:
Modifiera föregående program så att det även startvärdet anges, med följande utskrift:
Ange start- och slutvärdet för uppräkningen: -2 5
-2, -1, 0, 1, 2, 3, 4, 5
Övning 0.1.25:
Modifiera föregående program så att det även skriver ut ”Nu är det noll!” på en egen rad när det
är 0, med följande utskrift:
Ange start- och slutvärdet för uppräkningen: -2 5
-2, -1, 0,
Nu är det noll!
1, 2, 3, 4, 5
Övning 0.1.26:
Modifiera föregående program så att utskriften räknar nedåt, med följande utskrift:
Ange start- och slutvärdet för uppräkningen: -4 6
6, 5, 4, 3, 2, 1, 0,
Nu är det noll!
-1, -2, -3, -4
Övning 0.1.27:
Skriv programmet ovn0127.java med följande utskrift:
Ange startvärde, steglängd och antal varv i lopen för uppräkningen: -7 3 8
-7, -4, -1, 2, 5, 8, 11, 14
875099958
11
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Övning 0.1.28:
Skriv programmet ovn0128.java som beräknar summan av termerna 1+2+3+4+…+n. Om
exempelvis n=3 är summan 6. Utskrifterna är följande:
Ange n: 5
Summan=15
Övning 0.1.29:
Skriv programmet ovn0129.java som beräknar produkten av termerna 1*2*3*4*…*n. Om
exempelvis n=4 är produkten 24. Utskrifterna är följande:
Ange n: 5
Produkt=120
Specialecken
\
Avänds om reserverade tecken ska skrivas ut, exempelvis \”
\t
Tabulator, d.v.s. inskjutning (indentering) av text.
\n
Ger ny rad
//
Kommentar på en rad
/*…*/ Kommentar över flera rader.
Övningar:
Gör övningarna 1-7 på sidan 24-25 i Java javisst!
Kursen Programmering 1 fortsätter nu i avsnitt 7 i detta kapitel.
875099958
12
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
2. Klasser och objekt (P1 och P2)
Inledningsvis visas en klass Person med instansvariabler för ålder, förnamn och efternamn, samt
ett par konstruktorer och några metoder:
public class Person {
private int age; //instansvariabel
private String fnamn; //instansvariabel
private String enamn; //instansvariabel
public Person(){ //konstruktor ger default-värden (förvalda) på instansvariablerna
age = 17;
fnamn = "Carl";
enamn = "Carlsson";
}
public Person( int age, String fnamn, String enamn){
//konstruktor med argument
this.age = age; //this används för att komma åt det egna objektet
this.fnamn = fnamn;
this.enamn = enamn;
}
public String SkrivPerson(){ //metoden returnerar alder, förnamn och efternamn för utskrift
return age + " " + fnamn +" "+ enamn;
}
public void setage(int c){
age = c;
}
//metod för att kunna ändra ålder
public void setfnamn(String c){ //metod för att kunna ändra förnamn
fnamn = c;
}
public int getAge(){ //metod för att ta reda på ålder
return age;
}
}
Ett program (klass) som använder klassen Person:
public class test_person {
public static void main(String[] args) {
//Objektet (instansen) p1 skapas (instansieras) från klassen Person med konstruktorn
Person(...)
Person p1 = new Person(35, "Therese", "Alshammar");
Person kalle; //Skapar referens för objektet kalle (som variabeldeklaration)
kalle = new Person(); //Objektet kalle skapas med defaultkonstruktorn Person()
System.out.println("Person 1: " + p1.SkrivPerson());
System.out.println( "Ålder på person Kalle: "+ kalle.getAge());
System.out.println( "Namn på kalle: "+ kalle.SkrivPerson());
kalle.setenamn("Svensson");
System.out.println( "Namn på kalle: "+ kalle.SkrivPerson());
}
}
Åtkomst och inkapsling
Genomgång av begreppen private och public i avsnittet Åtkomst i objekt (kapitel 2 s. 19).
875099958
13
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Övning 0.2.1:
Skapa klassen Klot.java i projektet kap2 med var en variabel för radie (double), en konstruktor
Klot() med värdet 1 för radien, en konstruktor Klot(double radie), metoden void volym() för
utskrift av klotets volymen och metoden double area() för beräkning av klotets area. Skriv även
ett program test_klot.java i projektet kap2 som inledningsvis skapar ett objekt med
defaultkonstruktorn Klot() och som sedan läser in en ny radie och skapar ett nytt objekt med
konstruktorn Klot(radie). Utmatningen ska fungera på följande sätt:
Volymen är 4.188786666666666
Arean är 12.56636
Ange radien: 2
Volymen är 33.51029333333333
Övning 0.2.2:
Skapa klassen Familj.java i projektet kap2 med en variabel antal_barn för antal barn, en
variabel mor för mammans namn, en variabel far för pappans namn, samt en fältvariabel
barn_namn för barnens namn. Konstruktorn Familj(antal, mor, far) skapar ett objekt för antal
barn, samt för mammans och pappans namn. Klassen har även följande metoder:





antal_barn(): returnerar antal (int) barn
mor_far(): returnerar namnen på båda föräldrarna med ”och” emellan.
las-in-barn(): läser in namnen på barnen till fältet barn med en for-lop.
skriv_ut_barn(): skriver ut namnen på barnen.
las_in_parents(): läser in föräldrarnas namn.
Klassen har följande struktur:
import
import
import
public
java.io.BufferedReader; //Alternativt: import java.io.*; för alla tre paket
java.io.IOException;
java.io.InputStreamReader;
class Familj {
private int antal_barn;
private String[] barn=new String[10];
private String mor,far;
public Familj( int antal_barn, String mor, String far){
this.antal_barn = antal_barn;
this.mor = mor;
this.far = far;
}
BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
public int antal_barn(){
...
}
public String mor_far(){
...
}
public void las_in_barn() throws IOException{
...
}
public void skriv_ut_barn() throws IOException{
...
}
public void las_in_parents() throws IOException{
...
}
}
875099958
14
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Programmet (klassen) familj_prog.java som använder klassen Familj har följande utseende:
import java.io.*;
public class familj_prog {
public static void main(String[] args) throws IOException{
Familj f1 = new Familj(3,"Gun","Jan");
System.out.println("Antal barn: "+f1.antal_barn());
System.out.println("Föräldrarna heter "+f1.mor_far());
f1.las_in_barn();
f1.skriv_ut_barn();
f1.las_in_parents();
System.out.println("Föräldrarna heter "+f1.mor_far());
}
}
En körning med programmet kan ha följande urskrifter:
Antal barn: 3
Föräldrarna heter Gun och Jan
Ange barnnamn 1: Eva
Ange barnnamn 2: Per
Ange barnnamn 3: Linda
Barn 1: Eva
Barn 2: Per
Barn 3: Linda
Ange moderns namn: Helena
Ange faderns namn: Viktor
Föräldrarna heter Helena och Viktor
Din uppgift är nu att skriva programkoden för metoderna i klassen Familj ovan. Lös förslagsvis
uppgiften genom att först skapa projektet familj med de båda klasserna Familj.java och
familj_prog.java i projektet kap2. Kopiera sedan in koden ovan och skriv klart metoderna.
Övning 0.2.3:
Nu ska du förbättra föregående program familj_prog.java (alternativt gör du ett nytt program
med namnet familj_meny.java) så att metoderna anropas via en while-loopad meny, enligt
nedan. Lägg även till metoden skriv_ut_parents() i klassen Familj.java, så att all utskrift sker
via metoder. Observera att metoden anropar en annan metod:
public void skriv_ut_parents(){
System.out.println("Föräldrarna heter "+mor_far());
}
En körning av programmet familj_prog.java kan se ut på följande sätt:
1: Skriv ut föräldrar.
2: Läs in barn.
3: Skriv ut barn.
4: Läs in föräldrar.
5: Avsluta.
Gör ett val: 1
Föräldrarna heter Gun och Jan
875099958
15
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Klassvariabler och fält av klasser
En klassvariabel är en static-deklarerad variabel i klass-filen som är oberoende av objekten, till
skillnad från instansvariablerna. Med deklarationen i klassen Familj.java…
public static int antal_familj=0;
…anropas klassvariabeln antal_familj med följande sats i ett javaprogram:
Familj.antal_familj++; //Observera att klassnamnet anges före punktnotationen.
Övning 0.2.4:
Modifiera föregående övning (alternativt gör du ett nytt program med namet
familjer_meny.java) ytterligare så att maximalt 10 familjer kan lagras i ett fält (register), med
följande fältdeklaration i programmet familj_prog.java:
Familj[] f = new Familj[10]; //skapar referenser till fältet (ej objekt)
I menyvalet nummer 0 nedan skapas ett nytt objekt (familj) med följande satser:
if (val==0){
Familj.antal_familj++;
f[Familj.antal_familj]=new Familj(); //skapar ett nytt objekt
f[Familj.antal_familj].las_in_antal_barn();
f[Familj.antal_familj].las_in_parents();
}
Där klassvariabeln antal_familj är static-deklarerad i klassen Familj.java, d.v.s. behåller sitt
värde i klassen oberoende av objekten. Så här ser menyn ut:
0: Skapa ny familj.
1: Skriv ut föräldrar.
2: Läs in barn.
3: Skriv ut barn.
4: Läs in föräldrar.
5: Skriv ut alla familjer.
6: Avsluta.
Gör ett val: 0
Ange antal barn: 1
Ange moderns namn: ewa
Ange faderns namn: jan
Klassen Familj.java har fått en tom konstruktor Familj(), samt metoden:
public void las_in_antal_barn()
Som läser in till variabeln antal_barn.
875099958
16
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Klassmetoder och final
En klassmetod är en static-deklarerad metod i klass-filen som liksom klassvariabler inte är
knuten till ett objekt och kan anropas utan att ett objekt behöver skapas. I följande klassen
Matte.java:
import java.text.*;
public class Matte {
public static double sqr(double x) { //klassmetoder föregås av static
return …;
}
public static double roten(double x) {
return …;
}
public static final double g = 9.824; //g kan ej ändras
public static String avrunda(double x, int n) { //avrund till n decimaler
NumberFormat r = NumberFormat.getInstance();
r.setMaximumFractionDigits(n);
return r.format(x);
}
}
…anropas med satsen:
Matte.roten(x); //Observera klassnamnet
Övning 0.2.5:
Nu ska du färdigställa klassen Matte.java ovan, samt skriva ett menystyrt program
matteprogram.java som gör lite beräkningar. Lös uppgiften på följande sätt:





Börja med att skapa klassen Matte.java i ditt projekt kap2.
Kopiera in koden ovan och skriv klart metoderna.
- sqr(x) beräknar kvadraten
- roten(x) beräknar kvadratroten
- avrrunda(x,n) avrundar x till n decimaler
Skapa programmet matteprogram.java.
Programmet visar följande meny:
- 1: Beräkna kvadratroten (läser in tal och antal decimaler som ska skrivas ut)
- 2: Beräknar fallsträcka (läser in tiden och beräknar med fysikformeln s=g∙t2/2
fallsträckan utan avrundning)
- 3: Avsluta
Vid beräkningarna används klassmetoder, samt gravitationskonstanten g i klassen
Matte.java.
*Övning 0.2.6:
Lös övningen Konsol-personbilar på sidan 23 i Java-javisst! kapitel 2.
*Övning 0.2.7:
Lös övningen Skjortor på sidan 2 i extra övningsuppgifter.
875099958
17
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
3. Arv (P2)
I detta avsnittet ska vi se hur instansvariabler och metoder i klasser kan ärvas till ärvas till andra
klasser. Begreppet arv är ett centralt begrepp i Java och modern programmering. Läs mer i
kapitel 3 i JavaJavisst!. Vi inleder med ett exempe som illustrerar begreppet arv.
Skapa klasser genom arv
Följand klass Raknesatt innehåller metoder för de fyra räknesätten, samt en konstant för talet pi:
public class Raknesatt {
public static final double pi = 3.1415;
public double add(double x, double y) {
return x+y;
}
public double diff(double x, double y) {
return x-y;
}
public double prod(double x, double y) {
return x*y;
}
public double kvot(double x, double y) {
return x/y;
}
}
Klassen innehåller ingen deklarerad konstruktor och får då automatiskt den tomma
defaultkonstruktorn:
Raknesatt(){}
Följande klass Fyrkant innehåller en metod för beräkning av arean hos en rektanger och ärver
eventuella protected- deklarerade instansvariabler, samt övriga public-deklarerade variabler och
metoder från klassen Raknesatt:
public class Fyrkant extends Raknesatt {//extends: arv från superklassen Raknesatt
protected String typ; //Kvadrat eller Rektangel.
protected double bredd, hojd;//Instansvariabler protected i superklass
public Fyrkant(String t, double b, double h) {
typ=t;
bredd=b;
hojd=h;
}
public Fyrkant() {}
//Tom konstruktor måste finnas för subklass Area
public double yta() {
//Beräknar arean av fyrkant
return bredd*hojd;
}
public String ge_typ() {//Ger typ av fyrkant
return typ;
}
}
875099958
18
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Följande subklass klass Area innehåller en metod som beräknar arean av en cirkel och ärver på
motsvarande sätt egenskaperna från superklassen Fyrkant och därmed också från klassen
Raknesatt:
public class Area extends Fyrkant {
private double radie;
public Area(double b, double h) { //konstruktor för fyrkant
typ="Fyrkant";
bredd=b;
hojd=h;
}
public Area(double r) {
//konstruktor för cirkel
typ="Cirkel";
radie=r;
}
public double cirkel_yta() {
return radie*radie*pi; //pi från superklass Raknesatt
}
}
Slutligen kommer klassen (javaprogrammet) TestRakna som använder klasserna ovan:
public class TestRakna {
public static void main(String[] args){
Raknesatt p = new Raknesatt();
//Raknesatt - superklass till Fyrkant
Fyrkant fyr=new Fyrkant("kvadrat",6,7);
//Fyrkant - superklass till Area, men subklass till Raknesatt
Area ar=new Area(2);
//ar är cirkel. Area - subklass till Fyrkant
Area a2=new Area(4,7); //a2 är en rektangel
System.out.println(p.add(2,5));
System.out.println(fyr.kvot(2,5));
System.out.println(Raknesatt.pi);
System.out.println(fyr.ge_typ());
System.out.println(Fyrkant.pi);
System.out.println("Fyrkantyta: "+fyr.yta());
System.out.println(Area.pi);
System.out.println(ar.kvot(1,3));
//ar och a2 når alla metoder i superklasser
System.out.println(ar.cirkel_yta()); //Beräknar cirkelyta
System.out.println(ar.ge_typ());
System.out.println(a2.yta());
//Beräknar rektangelyta
System.out.println(a2.ge_typ());
}
}
Ger följande utskrift:
7.0
0.4
3.1415
kvadrat
3.1415
Fyrkantyta: 42.0
3.1415
0.3333333333333333
12.566
Cirkel
28.0
Fyrkant
875099958
19
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Klasserna ärver endast ”bakåt”, d.v.s. metoden cirkel_yta() i klassen Area är inte åtkomlig i
klassen är inte åtkomlig i Fyrkant. En variant är dock att klassen Fyrkant ärver (extends) av
klassen Area, som ärver (extends) av klassen Fyrkant. Fungerar detta?
Sammanfattning av arvbegrepp
Superklass
Klass arvet sker från
Subklass
Klassen som ärver
Extends
Anger arv
Override
Metoder med samma namn i subklass (överskuggar). Kallas polymorfism.
Default konstruktor
Superklassen måste alltid innehålla en tom konstruktor.
Protected
Istället för private framför instansvariabler i superklass.
Övning 0.3.1:
Du ska skriva ett javaprogrammet Personal.java och två klasser, Person och Larare, där
Larare är en subklass till klassen Person. Lös uppgiften på följande sätt:

Klassen Person har de tre instansvariablern fnamn och enamn (String) för personens föroch efternamn, samt f_ar (int) för personens födelseår (typ 1995) och konstruktorn
Person(fnamn, enamn, f_ar) och den tomma defaultkonstruktorn Person() {}. Metoden
age(nu), som tar aktuellt årtal nu (int) och returnerar personens ålder (int).

Subklassen Larare ärver från klassen Person, vilken har instansvariablern lon (int) för
personens månadslön och anst_ar (int) för personens anställningsår (typ 2009),
konstruktorn Larare(fnamn, enamn, f_ar, lon, anst_ar), samt metoderna skriv_ut(), som
skriver ut all information om läraren (se program nedan) och visa_antsällningsar(nu),
som skriver ut en ”o” för varje år läraren varit anställd (se program nedan).

Programmet Personal.java har följande utseenede:
public class Personal {
public static void main(String[] args){
Larare l = new Larare(“Jan”,“Gran”,1976,28000,2005);
l.skriv_ut();
System.out.println(”Lärarens ålder: ”+l.age(2012));
l.visa_anställningsar(2012);
}
}
Och får då utskriften:
Förnamn: Jan
Efternamn: Gran
Födelseår: 1976
Lön: 28000 kr/månad
Anställningsår: 2005
Lärarens ålder: 36 år
Antal anställningsår: ooooooo
Börja med att skapa projektet kap3 i Eclipse där du sparar alla filer (klasser) och lös sedan
uppgiften.
System.out.println(a2);
875099958
//utan metodnamn
20
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Metoden toString()
Om en metod döps till toString(), som finns i klassen Object alla klasser ärver ifrån, anropas den
endast med objektreferensen. Om i programmet TestaRakna ovan metoden ge_typ() istället ges
namnet toString() anropas den på följande sätt:
System.out.println(a2); //Endast med objektsreferensen
Övning 0.3.2:
a) Du ska nu göra en klass Rat_triangel med en metod double area() som beräknar arean av en
rätvinklig triangel och en metod double pyth() som beräknar triangelns hypotenusa. Klassen
har de två instansvariablerna double bas, hojd, samt de tre konstruktorerna Rat_triangel(bas,
hojd), Rat_triangel() och toString(), som returnerar höjden och basen (se utskrift nedan).
Med programmet nedan, som du kopierar till en ny klass TestTriangel.java i projektet kap3:
public class TestTriangel {
public static void main(String[] args){
Rat_triangel t=new Rat_triangel(3,4);
System.out.println(“Hypotenusan=”+t.pyth(3,4));
System.out.println(“Arean=”+t.area(3,4));
System.out.println(t);
}
}
Blir utskriften:
Hypotenusan=5.0
Arean=6.0
Basen=3.0 Höjden=4.0
b) Gör nu så att klassen Raknesatt ovan blir en superklass till Rat_triangel. TestTriangel
modifieras sedan till:
System.out.println(t.prod(5,7)); //Vad blir ur skriften?
c) Gör nu istället så att Rat_triangel blir en superklass till Raknesätt. TestTriangel modifieras
sedan till:
Raknesatt r=new Raknesatt();
System.out.println("Hypotenusan="+r.pyth(3,4));
System.out.println("Arean="+r.area(4,6));
//Vad blir utskrifterna?
d) Gör nu så att Rat_triangel ärver från TestTriangel, som ärver från Rat_triangel. Vilka
felmeddelanden får du och vad händer om du försöker köra programmet? Vilken slutsats drar
du av detta?
*Övning 0.3.3:
Lös övningen Konsol-combi-bilar på sidan 8 i Java-javisst! kapitel 3.
*Övning 0.3.4:
Lös övningen Klassen-person på sidan 10 i Java-javisst! kapitel 3.
*Övning 0.3.5:
Lös övningen Arv i flera generationer på sidan 11 i Java-javisst! kapitel 3.
*Övning 0.3.6:
Lös övningen Metoden toString() på sidan 12 i Java-javisst! kapitel 3.
875099958
21
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Egna paket
Via import-satsen i början av javaprogrammet får vi tillgång till javas befintliga klasser genom
att importera paket (package). Vi kan även skapa egna paket för klasser och metoder vi gjort och
vill återanvända. Paketen kan göras tillgängliga endast i ett Eclipse projekt eller i alla mappar.
Följande punkter visar hur vi skapar och använder ett eget paket:

Skapa ett nytt projekt aa_test i javamappen i Eclipse.

Skapa en klasses TestaRaknesatt i projektet, med koden:
import java.util.*;
import mittpaket.*;
public class TestaRaknesatt{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
double x, y;
System.out.print("Skriv ett decimaltal: ");
x = sc.nextDouble();
System.out.print("Skriv ett decimaltal till:");
y = sc.nextDouble();
Raknesatt r = new Raknesatt();
System.out.println("Summan är " + r.add(x,y));
System.out.println("Differensen är " + r.diff(x,y));
}
}

Skapa paketet mittpaket, med projektet aa_test markerat: File -->
New --> Package --> mittpaket --> Finish.

Skapa klassen Raknesatt i mittpaket med koden:
package mittpaket;
public class Raknesatt {
public static final double pi = 3.1416;
public double add(double x, double y) {
return x+y;
}
public double diff(double x, double y) {
return x-y;
}
public double prod(double x, double y) {
return x*y;
}
public double kvot(double x, double y) {
return x/y;
}
}

Spara allt och provkör TestaRaknesatt.

Kolla i mappen aa_test i utforskaren, vilken bör ha strukturen:
aa_test
src
TestaRaknesatt.java
mittpaket
Raknesatt.java
bin
TestaRaknesatt.class
mittpaket
Raknesatt.class
875099958
22
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Alla klasser som tillhör projektet aa_test kan nu använda paketet mittpaket, som endast är
definierat i projektet aa_test. Vi vill nu göra klasserna och metoderna i paketet mittpaket
tillgängliga via import-satsen för andra javaprogram. Detta görs på följande sätt:

Skapa en ny mapp under förslagsvis C:\, t ex C:\minaklasser och kopiera dit mittpaket
med Raknesatt.class. Strukturen blir där:
C:\minaklasser
mittpaket
Raknesatt.class

Skapa det nya projektet testa i javamappen. I det projektet skapas klassen TestaRaknesatt,
enligt ovan.

Kör programmet, vilket inte fungerar eftersom paketet mittpaket inte hittas.

Lägg till C:\minaklasser i ClassPath, via Start/högerklicka Dator/Egenskaper/Avancerade
systeminställningar/Miljövariabler/Redigera classpath.

Kör programmet igen. Fungerar det nu? Om inte – gör följande:

Högerklicka projektet testa. I menyn välj Properties/Java Build Path --> fliken Source -->
Link Sourse --> browse till minaklasser --> ok – Finish.

Provkör igen. Nu bör det fungera.

Att testa: Fungerar det även om man tar bort ClassPath C:\minaklasser ovan?
875099958
23
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
4. GUI-Program med Swing (P1, P2)
I detta avsnitt kommer vi att börja använda GUI (Graphical User Interface) i våra program, det
vill säga textobjekt, knappar och textfält för inmatning.
Frame-objekt
Genomgång av övning En enkel GUI-applikation på sidan 4-5 i Java-javisst! kapitel 4 som
skapar ett tomt fönster (container) med klassen JFrame i paketet javax.swing. Nedan visas
klassen (programmet) JFrameTest.java, som ärver (extends) från klassen JFrame. Alla klasser
som tillhör paketet jawax.swing börjar på stora ’J’.
import javax.swing.*;
import java.awt.*;
public class JFrameTest extends JFrame {
public static void main(String[] args) {
JFrameTest f = new JFrameTest ();
f.setSize(300, 100);
f.setLocation(100,100);
f.setTitle("Övning 0.4.3");
f.setDefaultCloseOperation(JPanelTest.EXIT_ON_CLOSE);
f.setVisible(true);
}
}
Textklassen JLabel
Genomgång av övning Lägg till en JLabel på sidan 6 i Java-javisst! kapitel 4 som skapar text
med klassen JLabel i paketet javax.swing. Textobjekten placeras ut med flytande layout
efterhand som de skapas med klassen FlowLayout i paketet java.awt. Kolla typsnitt, stil,
textfärg etc. Observera att label-objekten skapas i klassen KnappFrames konstruktor.
import javax.swing.*;
import java.awt.*;
public class JFrameTest extends JFrame {
JLabel lbl;
public JFrameTest () {
//Konstruktor
this.setLayout( new FlowLayout() );
lbl = new JLabel("Detta är en JLabel!");
lbl.setFont(new Font("Arial",Font.ITALIC ,20));
lbl.setForeground(Color.red);
Metoder för textformatering:
this.add(lbl);
}
lbl.setFont(new Font("Arial",Font.ITALIC ,20));
public static void main(String[] args) {
lbl.setForeground(Color.yellow);
JFrameTest f = new JFrameTest ();
lbl.setOpaque(true);
f.setSize(300, 100);
lbl.setBackground(Color.blue);
f.setLocation(100,100);
f.setTitle("Övning 0.4.3");
f.setDefaultCloseOperation(JPanelTest.EXIT_ON_CLOSE);
f.setVisible(true);
}
}
Följande stilar finns: Font.PLAIN, Font.ITALIC, Font.BOLD eller med additionen Font.ITALIC +
Font.BOLD (för kursiv + fet stil). Med följande sats tilldelas labeln lbl en text: lbl.setText("Hej " );
875099958
24
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Övning 0.4.1:
Skapa javaprojektet kap4 i din
javamapp med Eclipse. Skapa sedan
programmet ovn041.java med ramen
och texten enligt urklippet till höger,
med storleken 300 x 100 pixlar.
Övning 0.4.2:
Modifiera föregående uppgift
så att texten får utseendet till
höger, med typsnittet Arial,
storlek 20p, kursiv och fetstil,
samt röd text med grön
bakgrund.
Övning 0.4.3:
Modifiera föregående
uppgift genom att
lägga in ytterligare ett
textobjekt med
storleken 100p. Ramen
har måtten 300 x 200
pixlar.
875099958
25
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Knappobjektet JButton och händelser
Genomgång av övning Byt färg på etikett på sidan 10, samt
övning Två knappar på sidan 11 i Java-javisst! kapitel 4.
Knappen knapp deklareras med klassen JButton ovanför
konstruktorn:
JButton knapp;
Och med följande kod i konstruktorn, tillsammans med den tidigare koden för texten (JLabel):
…
knapp = new JButton("En knapp");
this.add(knapp);
…
I följande exempel byter texten färg från rött rill grönt när knappen klickas med hjälp av
händelsemetoden actionPerformed():
…
import java.awt.event.*;
//Paket för att kolla händelser
public class JFrameTest extends JFrame implements ActionListener { //Från gränssnittet ActionList…
JLabel lbl;
JButton knapp;
public JFrameTest () {
this.setLayout( new FlowLayout() );
lbl = new JLabel("Detta är en JLabel!");
lbl.setFont(new Font("Arial",Font.ITALIC ,20));
lbl.setForeground(Color.red);
knapp = new JButton("Tryck här");
knapp.addActionListener(this); //Lyssnar på knappen
this.add(knapp);
this.add(lbl);
}
public void actionPerformed(ActionEvent e){
lbl.setForeground(Color.green);
}
//Metoden actionPerformed finns i gränssnittet
…
Finns flera knappar (knapp1 och knapp2) kollar följande kod vilken av knapparna som orsakat
händelsen:
public void actionPerformed(ActionEvent e){
if( e.getSource() == knapp1) lbl.setBackground(Color.blue);
if( e.getSource() == knapp2) lbl.setBackground(Color.red);
}
Övning knappar:
Skapa klassen Knapp och skriv ett program med
tre knappar och en text, vars färg ändras när
knapparna klickas. Urklippet till höger visar hur
det ska se ut och programmet skall fungera som
exemplet knappar.jar. När sista knappen klickas
blir det ju en grön bakgrund till texten, som ligger
kvar när de andra knapparna klickas. Gör så att den gröna bakgrunden försvinner när de andra
knapparna klickas.
875099958
26
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Textfältet JTextField
Genomgång av övningarna Skriv in en text på sidan 12,
Textfältet kan lyssna och Ändra textens utseende (samma
som för JLabel) på sidan 13, Mata in tal på sidan 14 i
Java-javisst! kapitel 4. Textfältet t2 deklareras med
klassen JTextField ovanför konstruktorn:
JTextField t2;
Och med följande kod i konstruktorn, tillsammans med den tidigare koden för texten (JLabel)
och knappen (JButton) skapas textfältet t2:
…
t2 = new JTextField(15);
t2 = new JTextField(“Skriv här”);
this.add(t2);
//Antal positioner
//Alternativt med text
//Textfältet adderas till framen
Här följer ytterligare några metoder för textfältet t2:
t2.addActionListener(this);
String ss = t2.getText();
t2.setText("Anders");
t2.setForeground(Color.red);
t2.setEnabled(false);
t2.setEditable(false);
t2.requestFocus();
t2.selectAll();
//Reagerar på Enter i textfältet och anropar actionPerformed(…)
//Textfältets innehåll tilldelas strängen ss
//Textfältet får strängen Anders
//Textfältets text blir röd
//Textfältet går ej att redigera och texten gråmarkeras
//Textfältet går ej att redigera, men men texten gråmarkeras inte
//Textfältet fokuseras
//Textfältets innehåll markeras, om det är fokuserat
Övning textfält:
Skapa klassen Textfalt och skriv
ett program som läser in ett föroch efternamn och som skriver ut
dem i en label, enligt urklippet och
exemplet inmata.jar. Inmatningen
ska även fungera med
Enterknappen i andra textrutan.
Övning textfält2:
Kopiera koden från föregående
övning och skapa klassen inmata2.
Ta sedan bort knappen ochh lägg
till ytterligare ett textfält.
Inmatningen sker nu istället med en
lyssnare i textfältet för efternamn,
vilken reagerar på enter-tangenten.
I det tredje textfältet, med
egenskapen setEditable(false),
Skrivs det inmatade för- och efternamnet ut med röd text. I det fjärde textfältet, med egenskapen
setEnabled(false), skrivs de inmatade namnen ut igen. Samtidigt markeras det inmatade förnamnet
och efternamnet raderas. Programmet ska fungera som inmata2.jar.
875099958
27
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Aritmetik, cast och typomvandling
Genomgång av aritmetik och omvandling (cast) mellan datatyper på sidorna 16-18 i Java-javisst!
kapitel 4. Observera särskilt:




Division mellan heltal (int) ger kvoten som heltal utan decimaler. Om variablera a=19 och
b=5 är deklarerade som int blir a/b=3. Om däremot variablerna är deklarerade som double
blir a/b=3,8.
Om a och b är heltal ger a%b resten vid division. Om variablera a=19 och b=5 är
deklarerade som int blir a%b=4, d.v.s. resten är 4. Vid exempelvis uppdelning av ett belopp i
olika valörar (sedlar och mynt) kan man ha nytta av detta:
…
int belopp, femti, tjugo, tio, fem, rest;
System.out.print("Ange ett belopp i kronor (mindre än 100 kr)?: ");
belopp = sc.nextInt();
femti = belopp / 50;
rest = belopp % 50;
tjugo = rest / 20;
rest = rest % 20;
tio = rest / 10;
rest = rest % 10;
fem = rest / 5;
rest = rest % 5;
System.out.println("Valörer - sedlar och mynt");
System.out.println("Femtio: " + femti);
…
Om x är ett decimaltal blir (int)x ett heltal. Om a är ett heltal blir (double)a ett decimaltal.
Detta kallas cast (omvandling) av datatyper.
Klassmetoderna Integer.parseInt(s) och Double.parseDouble(s) omvandlar strängen s (om den
är ett tal!) till ett hel- respektive decimaltal.
Övning 0.4.4a:
Skriv ett program som läser in två heltal och beräknar som skriver ut kvoten, heltalskvoten, och
resten med följande utskrift:
Ange två heltal: 19 5
Kvoten: 3.8
Heltalskvoten: 3
Resten: 4
Övning 0.4.4b:
Skriv ett program som läser in ett belopp i kronor och som sedan delar upp det i befintliga
valörer av sedlat och mynt. Använd koden i exemplet ovan. Programmet ska ha följande utskrift:
Ange ett belopp i kronor: 748
Valörer: 500:1, 100: 2, 50:0, 20:2; 10:0, 5:1, 1:3
*Övning 0.4.4c:
Skriv ett program som omvandlar ett decimalt tal till ett binärt tal. Exempelvis är det binära talet
101 det decimala talet 5, samt 11011 det decimala talet 27. Från höger är varje talposition värd 1,
2, 4, 8, 16, 32, 64 o.s.v. Programmet har följande utskrift:
Ange ett decimaltal: 27
Omvandlat till binärt tal: 11011
875099958
28
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Övning 0.4.4:
Skapa klassen
InmataTal i Eclipse.
Skriv sedan ett
program som beräknar
med de fyra
räknesätten för heltal,
enligt urklippet till
höger.
Övning 0.4.5:
Modifiera föregående
övning så att den även fungerar för decimaltal.
Övning 0.4.6:
Skriv ett program
som skriver ut
heltalskvoten och
resten vid division
mellan två heltal,
enligt urklippet
till höger.
875099958
29
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
ASCII-standard och Unicode
Varje tecken (a, b, 2, %...) var i datorns barndom förknippat med ett nummer mellan 0 och 127,
d.v.s. en 7-bitars ASCII-kod. Detta räckte så länge endast bokstäverna a-z användes. Senare fler
tecken behövdes utökades detta till en 8-bitars kod (1 byte) som omfattar 256 (0-255) olika
tecken. I Java används 16-bitars Unicode, som alltså kodar för 65 536 olika tecken, där de första
255 är samma som i ASCII-standarden. Följande javakod omvandlar mellan Unicode och och
tecken:
(int)t; //ger Unicoden för tecknet som är lagrat i char-variabeln t
(char)h; //ger tecknet med Unicoden som är lagrad i int-variabeln h
Eftersom inläsning från textrutor (.getText()) alltid görs som strängar (String-typ), måste man
kunna ange ett visst tecken i strängen s. Detta gös med javakoden:
s.charAt(0); //som ger första (nollte) tecknet i strängen s
Övning 0.4.7:
Skriv ett program som
läser in ett tecken och en
Unicode i två textrutor och
skriver ut motsvarande
Unicode respektive tecken
i två lablar, enligt
urklippet till höger.
Övning 0.4.8:
Skriv ett program som
skriver ut Unicoden 50-127
och motsvarande tecken i en
tabell, enligt urklippet intill.
Använd förslagsvis klassen
JTextArea, som fungerar
som en textruta, men som
har ett antal rader och
kolumner och kan bryta rad.
Detta deklareras på följande
sätt:
JTextArea tt;
tt = new JTextArea(5,20); //5 rader och 20 kolumner, lägger till fler rader vid behov
tt.setLineWrap(true); //bryter rad
add(tt);
Ledning: Addera strängen i for-loopen innan den skrivs ut i textarean: s=s+" "+i+":"+(char)i;
875099958
30
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Klassen Math
Klassen Math och dess klassmetoder sammanfattas i kapitel 1 i detta dokumentet, samt på sidan
18 i kapitel 4 i Java-javisst!.
Övning 0.4.9a:
Skriv ett program som skriver ut tio slumptal mellan 1 och 10, men följande utskrift i konsollen:
Tio slumptal: 3 1 5 4 10 2 2 3 7 8
Övning 0.4.9b:
Modifiera föregående program så det läser in det högsta slumptalet (heltal), samt antalet slumptal
som ska genereras och som sedan beräknar medelvärdet av slumptalen. Det lägsta slumptalet är
1. Utskriften i konsollen är följande:
Ange det högsta slumptalet: 100
Ange antal slumptal: 150
Medelvärdet av slumptalen är 51.306666666666665
Övning 0.4.9c:
Skriv om föregående program
så att inmatning av högsta och
antal slumptal görs i textrutor
och utskriften i en label, enligt
urklippet till höger.
Programmet ska fungera som
slumpmedel.jar.
Övning 0.4.9d:
Skriv ett program som
läser in två kateter och
beräknar hypotenusan med
Pythagoras sats.
Övning 0.4.9:
Skriv ett program som slumpar två heltalsfaktorer
mellan 1 och 10 och som sedan kollar om det inmatade
talet är produkten av faktorerna. Antal försök, rätt och
fel skrivs ut. Inmatning görs med Enter-tangenten. Efter
tio försök går det inte att göra fler inmatningar i
textrutan. Detta åstadkoms med satsen:
tf1.setEnabled(false); //tf1 är textfältet
Programmet ska fungera som multi.jar.
875099958
31
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Felhantering med try-catch
Vi går igenom try-catch-konstruktionen för att ta hand om fel vid inmatning. Om exempelvis en
bokstav matas in istället för en siffra i föregående uppgift kan vi med hjälp av try-catch undvika
att exekveringen avbryts. Läs om detta på sidan 20 i kapitel 4 i Java-javisst!.
Övning 0.4.10:
Modifiera föregående multiplikationsövning på
följande sätt:

Så att den ger ett felmeddelande i andra
etiketten om en bokstav matas in.

Matas en bokstav in ska Antal försök inte ökas.

Så att det minsta värdet på faktorerna är 2 och inte 1 som i förra exemplet (för enkelt!).

Antalet försök räknas ner från 10 till 0.

Lägg in en knapp som blir klickbar när antal kvarvarande försök är 0. Lägg in lyssnaren
b.addActionListener(this);
för knappen och händelsehanteraren
if(e.getSource()==b) ny(); //se nedan
i metoden actionPerformed(ActionEvent e)

När knappen klickas initieras en ny omgång via den egna metoden ny():
public void ny(){
ratt=0;
fel=0;
antal=10;
lbl2.setText("Antal försök kvar: 10
Antal rätt: 0
tf1.setEnabled(true);
b2.setEnabled(false);
x =1+ (int)Math.ceil(Math.random()*9);
y = 1+(int)Math.ceil(Math.random()*9);
lbl1.setText(x+" x "+y+" = ");
Antal fel: 0");
}
Programmet ska fungera som mult_ovn2.jar.
875099958
32
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Avrundning och utskriftsformatering
Vi går igenom avrundning på sidan 21 i Java-javisst! kapitel 4 med metoden String.format(…),
samt i detta dokument på sidan 76 i detta dokumentet med metoden NumberFormat i paketet
java.text.*. Följande satser gäller:
System.out.println(String.format("%10s","kalle")); //strängen kalle på 10 positioner
System.out.print(String.format("%4d",n));
//heltalet n på 4 positioner
System.out.println(String.format("%7.3f",x)); //decimaltalet x med 3 decimaler på 7
poitioner
Övning 0.4.11:
Skriv ett program som i konsolen läser in ett tal och som sedan skriver ut talets kvadratrot utan
avrundning och med avrundning till tre decimaler på sju positioner (högerjusterat), enligt
utsktiften:
Skriv ett tal: 2
Kvadratroten är 1.4142135623730951
Roten är
1,414
Övning 0.4.12:
Lös övning Cirkel på sidan 18 i Java-javisst! kapitel 4, som skriver ut area och omkrets avrundat
till två decimaler med String.format(…). Programmet ska fungera som cirkeln.jar. Ledning:
Utskriften görs förslagsvis med satsen:
lbl_area.setText("Area= " + String.format("%1.2f", area)+" cm2");
Övning 0.4.13:
Modifiera uppgift 0.4.9d ovan om Pythagoras så att svaret avrundas till en decimal med
NumberFormat. Programmet ska fungera som hypotenusa.jar.
*Övning 0.4.14:
Gör ett program tabell.java som i konsolen skriver ut värdetabellen för kvadratroten ur x, x2, x3
och x4 nedan. Observera att alla utskrifter görs på åtta positioner:
x
0
1
2
3
4
5
rot
0,000
1,000
1,414
1,732
2,000
2,236
875099958
x2
0
1
4
9
16
25
x3
0
1
8
27
64
125
x4
0
1
16
81
256
625
33
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
5. Grafik, bilder och ljud (P2)
Avsnittet bygger vidare på avsnitt 4 och fördjupar konskaperna om grafiska objekt och
komponenter. Innehållet anknyter till kapitel 5 i Java-javisst!.
Klassen JPanel
Här här grundkoden för ett program med klassen JPanel som skapar panelen till höger på en
JFrame som grundplatta. JFrame-objektet har BorderLayout (inte FlowLayout) som standard,
varför panelen fyller ut hela JFramen:
import javax.swing.*;
import java.awt.*;
public class MinJPanel extends JPanel {
public MinJPanel () {
this.setBackground(Color.red);
}
public static void main(String[] args) {
JFrame f = new JFrame();
f.setSize(400, 300);
//Storlek
f.setLocation(100,100); //Placering
f.setTitle("Min JPanel!");
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
MinJPanel p = new MinJPanel ();
f.add(p);
f.setVisible(true);
}
}
Panelen kan nu användas som grundplatta för olika typer av objekt.
JPanel som rityta
Klassen Graphics innehåller många olika typer av ritbojekt såsom linjer, rektanglar, cirklar,
polygoner och text som kan ritas på panelen. Följande kod visar ett exempel på en yta ritar en
rektangel och en text i metoden paintComponent(Graphics g):
import javax.swing.*;
import java.awt.*;
public class MinJPanel extends JPanel {
public MinJPanel () {
this.setBackground(Color.yellow);
}
public void paintComponent(Graphics g){
super.paintComponent(g);
g.drawRect(50,75,100,50);
g.drawString("Text på panelytan",20 , 30);
}
public static void main(String[] args) {
JFrame f = new JFrame();
f.setSize(300, 200);
f.setLocation(100,100);
f.setTitle("Min JPanel!");
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
MinJPanel p = new MinJPanel ();
f.add(p);
f.setVisible(true);
}
}
875099958
34
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Färger, text och figurer
Det finns både klasser och metoder för inställnig av RGB-färg och text. Följande ändringar i
metoden paintComponent(Graphics g) justerar texten, samt ger olika färg på texten och den fyllda
cirkeln:
public void paintComponent(Graphics g){
super.paintComponent(g);
Color c=new Color(255,0,255);
g.setColor(c);
g.fillOval(100,50,100,100);
Font f=new Font("Arial",Font.BOLD,24);
g.setFont(f);
c=new Color(255,0,0);
g.setColor(c);
g.drawString("Text på panelytan",20,30);
}
Följande metoder finns för klassen Graphics:
drawLine(x1,y1,x2,y2);
//Ritar en linje mellan koordinaterna (x1, y1) och (x2, y2)
drawRect(x,y,b,h);
//Ritar en rektangel med övre vänstra hörnet i (x, y), bredd b och höjd h
fillRect(x,y,b,h);
//Fyller rektangeln
drawRoundRect(x,y,b,h,m,n) //Rektangel med rundade hörn, där m och n anger rundning
fillRoundRect(x,y,b,h,m,n)
//Fyller rundad rektangel
draw3DRect(x,y,b,h,upp)
//Tredimensionell rektangel, upp är true eller false
fill3DRect(x,y,b,h,true/false)
//Ger en (svag) tredimensionell effekt false/true=upp/ner
drawOval(x,y,b,h)
//Ritar en oval
fillOval(x,y,b,h)
//Fyller en oval
drawArc(x,y,b,h,s,l)
//Ritar en båge, där s är startpunkt ock I slitpunkt I grader
drawPolygon(xp,yp,n)
//Ritar en polygon. Koordinaterna (n st) ligger i fälten xp och yp
fillPolygon(xp,yp,n)
//Fyller polygonen
drawString(”Lite text”,x,y)
//Skriver ut ”Lite text” till höger om koordinaten x,y
this.getWidth(), this.getHeight()
//Ger panelens bredd respektive höjd
fillArc( x,y,b,h,u,v);
//Fyller en sektor med centrumvinkeln v med början vid vinkeln u (grader)
repaint();
//Ritar om panelen (utan g. framför)
Övning 2.1-Övning 2.8:
Övningarna finns här på s.44 nedan.
Visa bilder
Med klassen ImageIcon kan följande kod visa bilder (.jpg, .gif) i originalstorlek i javaprogram:
public class VisaBild extends JPanel {
ImageIcon jumbo;
public VisaBild () {
jumbo = new ImageIcon("jumbo.gif");
this.setBackground(Color.white);
}
public void paintComponent(Graphics g){
super.paintComponent(g);
jumbo.paintIcon(this, g, 50, 50); //Bildens vänstra hörn har koordinaten (50, 50)
}
875099958
35
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Rekursion
Med begreppet rekursion i datasammanhang menas en procedur eller funktion som anropar sig
själv. Rekursion användas för att åtstadkomma upprepningar där det är svårt att använda loopar,
exempelvis används det ofta vid beräkning och uppritning av s k fraktaler (mer om detta senare).
I följande exempel beräknas summan 1+2+3+4+5 först på ett traditionellt iterativt sätt med en
for-loop och sedan med en rekursiv funktion:
import java.util.Scanner;
public class reksum{
public static int summa(int n) {
int sum=0;
for (int i=1;i<=n;i++)
sum=sum+i;
return sum;
}
//metod summa(n) för summering med iteration
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int n;
System.out.print("Ange ett heltal: ");
n = sc.nextInt();
System.out.print("Summan="+summa(n));
}
}
Samma summering görs igen, men med den rekursiva metoden rsumma(n);
import java.util.Scanner;
public class reksum{
public static int rsumma(int n) {
if (n==1)
return 1;
else
return n+rsumma(n-1);
}
//rekursiva metoden rsumma(n) för summering
//Förklara hur funktionen fungerar!
//Funktionen anropar sig själv (=rekursion)
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int n;
System.out.print("Ange ett heltal: ");
n = sc.nextInt();
System.out.print("Summan="+reksumma(n));
}
}
Övning 0.5.1:
Talföljden 1, 1, 2, 3, 5, 8, 13, 21…är de första åtta talen i Fibonaccis talföljd. Skriv ett program
(det ovan i exemplet) med en metod fib(n) som beräknar det n:te fibonaccitalet med en:
a) Iterativ metod.
b) Rekursiv metod.
Programmet ska i båda fallen ha utskrifterna:
Ange ett heltal: 7
Motsvarande fibonaccital är 13
875099958
36
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Övning 0.5.2:
Skriv en funktion fak(n) som beräknar produkten 1234… n. Produkten kallas fakultet.
Funktionen skall anropas rekursivt och sakna loopar. Programmet har utskriften:
Ange ett heltal: 4
Fakulteten är 24
Övning 0.5.3:
Skriv en metod roten(x1, x2) som beräknar en
funktions nollställe (skärning med x-axeln) med
intervallhalvering. Det fungerar på följande sätt:
Proceduren roten(x1, x2) anropas med två värden, ett
x-värde till vänster (x1) om nollstället och ett x-värde
(x2) till höger om nollstället (se figuren).
Metoden räknar sedan ut x-värdet (xmitt) mitt emellan
x1 och x2, och kollar därefter om funktionen skär xaxeln mellan x1 och xmitt eller mellan xmitt och x2.
Funktionen skär x-axeln emellan x1 och xmitt om
produkten av funktionsvärdena för x1 och xmitt är
negativ. Då anropas proceduren rekursivt:
y
y
x1
x
x2
xmitt
roten(x1, xmitt)
Skär funktionen i det andra intervallet blir anropet:
roten(xmitt, x2)
Detta pågår tills intervallet är godtyckligt litet, t ex när differensen abs(x2 - x1) < 0,00001 om
man vill ha fem siffrors noggrannhet i roten. Metoden returnerar då xmitt. Förslagsvis beräknas
funktionsvärdet i en separat metod f(x). Programmet skall fungera som exemplet I detta och
följande två exempel används funktionen y = 2 - x2, som har rötterna  2  1,41421... Prova
gärna med andra funktioner. Vilka rötter har t ex funktionen y = sin(x) ? Programmet har
utskriften:
Ange ett intervallgränserna x1 och x2: 1 5
Kvadratroten ur 2 är 1.4142112731933594
Rätt värde är
1.414213562
Övning 0.5.4:
Intervallhalvering har dålig konvergens vid rotberäkning, d v s det krävs många beräkningar
(intervallhalveringar) för att få fram ett bra värde på roten Modifiera föregående program så att
det skriver ut xmitt-värdet vid varje intervallhalvering i metoden roten(…).
*Övning 0.5.5:
Newton-Raphsons metod för rotberäkning är betydligt
effektivare än intervallhalvering. Om roten x söks i
ekvationen:
0  f ( x)
Beräknas roten med följande iterationsformel:
f ( x1 )
,
x2  x1 
f ( x1 )
Iterationen pågår tills tillräcklig noggrannhet erhålls,
exempelvis när följande villkor är uppfyllt:
x1  x 2  0,000001
y
y
x1
x2
Newton-Raphsons metod bygger på att tangenten f´(x1):s skärning med x-axeln (x2) beräknas
upprepade gånger. Skriv ett program med en metod raphson(x1, x2) som skriver ut x-värdet vid
varje intervallhalvering.
875099958
37
Brogårdsgymnasiet
x
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Grafik med rekursion
Grafik kan ibland vara enklare att rita med rekursiva metoder än med iterativa. Viss typ av
grafik, exempelvis s.k. fraktaler, är nästan bara möjlig att rita med rekursiva metoder, som vi ska
se nedan. Inledningsvis ett programexempel med en enkel rekursiv grafisk metod
rita(Graphics g,int n,int x, int y) som skriver ut värdet av en variabel n diagonalt i en panel.
Observera att metoden inte returnerar något värde (void):
import javax.swing.*;
import java.awt.*;
public class rekfyrkant extends JPanel {
public rekfyrkant () {
this.setBackground(Color.white);
}
public void rita(Graphics g,int n,int x, int y){
if (n>=1){
g.drawString("Nr="+n,x,y);
rita(g,n-1,x+50,y+50);
}
}
public void paintComponent(Graphics g){
super.paintComponent(g);
rita(g,4,20,20);
}
public static void main(String[] args) {
JFrame f = new JFrame();
f.setSize(250, 250);
f.setLocation(200,100);
f.setTitle("Bengt");
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
rekfyrkant p = new rekfyrkant ();
f.add(p);
f.setVisible(true);
}
}
Strukturer och mönster som i någon mening
upprepar sig förekommer på många ställen i
naturen, t ex strukturen hos ormbunksbladet,
snöflingan och grenverket hos ett träd. Även
mönstret hos kustlinjen på en karta upprepar
sig på ett regelbundet sätt om kartan studeras i
olika skalor. Dessa upprepande eller
självliknande mönster kallas alltså fraktaler.
875099958
38
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Cantor-mängden
Ett enkelt fraktalt mönster är
den s.k. Cantormängden (se
figur), efter den rysk-tyske
matematikern Georg Cantor.
Det är en linje som ritas
upprepade gånger, men där
1/3 av linjen plockas bort för varje ritning. I figuren är linjen ritad tio gånger, men redan efter
sex uppritningar begränsar upplösningen bildkvaliteten. Fraktala mönster ritas nästan uteslutande
med rekursiva metoder och kan därför ofta ritas med relativt enkel programkod, trots att
mönstren förefaller komplicerade. Cantormängden ovan är ritad med följande programkod:
public void rita(Graphics g,double x1,double x2, int y,int n){
double x3, x4;
g.drawLine((int)Math.round(x1),y,(int)Math.round(x2),y);
if (n > 1){
x3 = x1+(x2-x1)/3;
x3
x1
x4 = x2-(x2-x1)/3;
rita(g,x1,x3,y+10,n-1);
rita(g,x4,x2,y+10,n-1);
}
}
public void paintComponent(Graphics g){
super.paintComponent(g);
rita(g,10,400,10,7);
}
x4
x2
Figuren ovan förklarar variablerna i programmet. Linjen x1-x2 är den första (understa) linjen
som ritas i cantormängden ovan. Linjerna x1-x3 och x4-x2 är den andra linjen som ritas med
tredjedelen i mitten borttagen. Linjerna ritas via 7 rekursiva anrop av proceduren rita, d v s
proceduren anropar sig själv.
Övning 0.5.6:
Kopiera koden ovan och rita cantormängden. Programmet skall fungera som exemplet cantor.jar.
n=2
n=0
Övning 0.5.7:
n=1
Gör ett program som ritar Sierpinski-triangeln,
efter den polske matematikern Waclav
Sierpinski, d.v.s. en triangel som delar upp sig i
ett antal mindre trianglar genom att
mittpunkterna på triangelns sidor förbinds med linjer. I figuren till höger visas de tre första
trianglarna. Programmet skall fungera som exemplet
sierpinski.jar, där n=5.
Övning 0.5.8:
Modifiera föregående program så att trianglarna
istället fylls med slumpmässiga färger, enligt exemplet
sierpinski_fylld.jar. Vid uppstarten ritas två delningar
(n=2). Sedan väljs antal delningar i inmatningsrutan.
Omritning sker med metoden repaint(); i metoden:
public void actionPerformed(ActionEvent e)
875099958
39
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Koch-kurvan
Ett annan relativt enkel fraktal
kurva är Koch-kurvan, efter den
svenske matematikern Helge von
Koch. Den skapas med en
generatorfigur (exempelvis
hattfunktionen i urklippet nedan)
som upprepas på sig själv, d v s
varje rak linje blir en ny mindre
hatt. I urklippet till höger visas
kurvan för olika värden på antal
upprepningar. Följande rekursiva
metod rita ritar Koch-kurvan,
dock upp och ned vänd, eftersom
y-axeln pekar nedåt i vårt
koordinatsystem:
public void rita(Graphics g,double x1,double y1,double x2,double y2,double hf,double ff, double v, int n){
double x3, y3, x4, y4, x5, y5, x6, y6, s, f, h;
if (n == 1)
g.drawLine((int)Math.round(x1),(int)Math.round(y1),(int)Math.round(x2),(int)Math.round(y2));
else{
s = Math.sqrt((x2 - x1)*(x2 - x1) + (y2 - y1)*(y2 - y1));
f = ff * s;
(x4, y4)
(x5, y5)
h = hf * s;
h
x3 = x1 + f * Math.cos(v);
y3 = y1 + f * Math.sin(v);
f
(x2, y2)
f
(x1, y1)
x6 = x2 - f * Math.cos(v);
(x6, y6)
(x3, y3)
y6 = y2 - f * Math.sin(v);
x4 = x3 + h * Math.cos(v+ Math.PI/2);
y4 = y3 + h * Math.sin(v + Math.PI/2);
x5 = x6 + h * Math.cos(v + Math.PI/2);
y5 = y6 + h * Math.sin(v + Math.PI/2);
rita(g,x1, y1, x3, y3, hf, ff, v, n-1);
rita(g,x3, y3, x4, y4, hf, ff, v + Math.PI/2, n-1);
rita(g,x4, y4, x5, y5, hf, ff, v, n - 1);
rita(g,x5, y5, x6, y6, hf, ff, v - Math.PI/2, n-1);
rita(g,x6, y6, x2, y2, hf, ff, v, n-1);
}
}
public void paintComponent(Graphics g){
super.paintComponent(g);
rita(g,10,50,400,50,0.3,0.4,0,3);
}
Beteckningarna visas i figuren, där s är avståndet mellan ändpunkterna 1 och 2. Parametrarna hf
och ff anger hur stor andel av s sträckan f (flanken) respektive h (höjden) skall vara (testa med
olika värden!). Parametern v (som här endast kan anta vinkelvärdena 0 och ±/2) anger hur en
linje skall ritas (lodrät eller vågrät).
Övning 0.5.9:
Kopiera koden ovan och rita Koch-kurvan. Programmet
skall fungera som exemplet kochkurva.jar. Urklippet till
höger är ritat för n=5. Rita för olika värden på n, hf och
ff. Vad händer om ff=0,5? Modifiera gärna så att n kan
anges via inmatningsruta.
875099958
40
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
*Övning 0.5.10:
Modifiera koden i föregående uppgift så, att
Koch-kurvan istället ritas med en trekantig
’hattfunktion’ (se bild). Sätt hf=ff=0,333, samt
vridningsvinkeln till ±/3 istället för ±/2. Programmet skall fungera som exemplet kochtri.jar.
Ormbunksblad
Utseendet hos blad och träd är i viss mån fraktalt. Mönstret hos den
ormbunksliknande figuren till höger upprepas i sina detaljer och är därför
enkel att rita med en rekursiv funktion. Programmet nedan visar koden:
public void rita(Graphics g,double x1,double y1,double d,double vinkel,double delta)
{
double x2, y2, v;
60o
v = Math.PI*vinkel/180;
60o
x2 = x1 + d * Math.cos(v);
x2, y2
y2 = y1 + d * Math.sin(v);
if (Math.abs(x1 - x2) > delta || Math.abs(y1 - y2) > delta)
{
d
g.drawLine((int)x1,(int)y1,(int)x2,(int)y2);
vinkel
rita(g,x2,y2,d * 0.83,3 + vinkel,delta);
rita(g,x2,y2,d * 0.3,vinkel - 60, delta);
rita(g,x2, y2, d * 0.3, 3 + vinkel + 60, delta);
x1, y1
}
}
public void paintComponent(Graphics g){
super.paintComponent(g);
rita(g,200,10,90,90,0.1);
}
Genom att variera värdet på vinklarna, reduceringsfaktorerna (0,83 och
0,3) och delta (upplösningen) kan utseendet på figuren förändras.
’Starrstrået’ till höger är ritat med reduceringsfaktorerna 0,5; 0,35;
0,35 och de fasta vinklarna 0 och 30 grader, samt parametrarna i
anropet är d=250 och delta=0,4.
Övning 0.5.11:
Kopiera koden ovan och rita bladet. Programmet skall fungera som
enligt exemplet blad.jar. Parametrarna d och delta kan anges i
inmatningsrutorna. Observera startvärdena. Gör gärna även
inmatningsrutor för reduceringsfaktorerna och de fasta vinklarna.
875099958
41
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Mandelbrotmängden
Benoi Mandelbrot är en fransk matematiker som
på 1970-talet upptäckte den nu s.k.
mandelbrotmängden. Mängden konstrueras
genom att upprepade gånger beräkna
z n 1  z n2  c tills beloppet på det komplexa
talet z blir stort (>100000) för slumpmässiga
värden på talet c. När och om villkoret är
uppfyllt avbryts iterationen. En svart pixel ritas i
koordinaten för c om (en variant är att välja en
färg utifrån värdet på n) villkoret inte uppfylls
innan n<200. Då avbryts beräkningen och talet
tillhör mandelbrotmängden. Talen z och c är
alltså komplexa tal, d.v.s. z = x+iy respektive c = cx+icy, där i2 = -1. Startvärdena för x och y är 0,
och de slumpmässiga värdena på c:s imaginär och realdel ligger i intervallen -2<cx<2 respektive
-2<cy<2. För att få med hela ’päronfiguren’ räcker dock om -2,03<cx<0,52 respektive 1,2<cy<1,2, enligt koden nedan. Provkör programmet som ritar figuren ovan, mandelbrot.jar.
Programkoden är här, som inte är rekursiv:
public void paintComponent(Graphics g){
super.paintComponent(g);
double x1, y1, x2, y2,s,x,y,cx=-2.03,cy=-1.2;
int n;
boolean go = true;
while (cx < 0.52){
cx = cx + 0.002;
cy = -1.2;
while (cy < 1.2){
x1 = 0;
y1 = 0;
cy = cy + 0.002;
n = 0;
s = 0;
while (s < 100000 && n <= 200){
x2 = x1*x1 - y1 *y1 + cx;
y2 = 2 * x1 * y1 + cy;
x1 = x2;
y1 = y2;
s = x1*x1 + y1*y1;
n = n + 1;
}
if (n >= 8 && n <= 200 && n%2==0){ //Villkor för att pixel ritas, endast vitt och svart.
x=800/2.55*(cx+2.03); //Skalning i x-led
y=600/2.4*(cy+1.2);
//Skalning i y-led
g.drawLine((int)x,(int)y,(int)x,(int)y); //Ritar en punkt
}
}
}
}
Övning 0.5.12:
Kopiera koden ovan och rita mandelbrotmängden ovan. Modifiera gärna programmet så att det
blir olika färger för olika maxvärden på n, d.v.s. antal iterationer innan det konvergerar. I
exemplet ritas endast svarta punkter för jämna värden på n. En annan variant är också att ändra
intervallet på det imaginära c för att zooma.
875099958
42
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Övning 0.5.13:
Skriv ett program
som ritar sektorer
med vinklar
inmatade i tre
textrutor, enligt
urklippet till höger.
Vinklarna ska
skrivas ut i
respektive sektor.
Programmet ska
fungera som
exemplet sektor.jar.
Övning 0.5.14:
Skriv ett program som ritar ut en
jpg-bild på tio slumpmässiga ställen
på panelen. De slumpmässiga
koordinaterna anpassar till panelens
storlek när den ändras med hjälp av
metoderna this.getWidth() och
this.getHeight(). Välj förslagsvis en
egen bild med förslagsvis storleken
100x100 pixlar. Programmet skall
fungera som exemplet icon.jar, som
anropar bildfilen aa.jpg.
Fullskärmsläge
Följande tre rader i main-metoden öppnar fönstret i fullskärmsläget:
public static void main(String[] args) {
JFrame f = new JFrame();
GraphicsEnvironment localEnvironment =GraphicsEnvironment.getLocalGraphicsEnvironment();
GraphicsDevice defaultDevice = localEnvironment.getDefaultScreenDevice();
defaultDevice.setFullScreenWindow(f);
//f.setSize(700, 700);
//f.setLocation(300,100);
…
875099958
43
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Ljud
Med följande kod kan ljudfiler av formatet .wav och .au startas och spelas en gång. Filerna läggs
i projektmappen.
import javax.swing.*;
import java.applet.*;
public class SpelaLjud extends JPanel
{
AudioClip ac;
public SpelaLjud() {
try{
ac = Applet.newAudioClip(new java.net.URL("file:horn.wav"));
}
catch(Exception exc){
System.out.println("Hittar ej");
}
ac.play();
}
Uppspelningen loopas med ac.loop() och stoppas med ac.stop().
Övning 0.5.15:
Skriv ett program med två knappar som byter färg på bakgrunden
och samtidigt startar respektive stoppar ett ljud, förslagsvis
au.laser på Java-javisst! hemsida. Layouten kan se ut som
urklippet till höger. Programmet skall fungera som exemplet
ljud.jar, som anropar en fil med namnet horn.wav.
875099958
44
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Egna grafiska klassen Cirkel
Ibland är det praktiskt att göra en egen klass för ett grafiskt objekt, vilket illustreras med följande
exempel. Först visas ett program EnCirkel som ritar en cirkel. Sedan ritas cirkeln igen av
programmet VisaCirkel, men då definierad som ett objekt via den egna klassen Cirkel. Här är
programmet EnCirkel som ritar cirkeln:
import javax.swing.*;
import java.awt.*;
public class EnCirkel extends JPanel {
int xpos, ypos, diam;
public EnCirkel () {
xpos = 40; ypos = 50; diam = 60;
this.setBackground(new Color(0,0,255));
}
public void paintComponent(Graphics g){
super.paintComponent(g);
g.setColor( new Color(255,225,0) );
g.fillOval(xpos, ypos,diam, diam );
}
public static void main(String[] args) {
JFrame f = new JFrame();
f.setSize(230, 230);
f.setLocation(100,100);
f.setTitle("EnCirkel");
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
EnCirkel p = new EnCirkel();
f.add(p);
f.setVisible(true);
}
}
Här är programmet VisaCirkel som ritar ut två cirklar med hjälp av klassen Cirkel, i rutan till
höger om programmet:
import javax.swing.*;
import java.awt.*;
public class VisaCirkel extends JPanel {
private Cirkel c1, c2;
public VisaCirkel () {
c1 = new Cirkel(20, 40, 60);
c2 = new Cirkel(110, 100, 80);
this.setBackground(new Color(0,0,255));
}
public void paintComponent(Graphics g){
super.paintComponent(g);
c1.visa(g);
c2.visa(g);
}
public static void main(String[] args) {
//Samma kod som föregående program
…
}
}
//klassen Cirkel
import java.awt.*;
public class Cirkel {
private int xpos, ypos, diam;
public Cirkel( int x, int y, int d ) {
xpos = x;
ypos = y;
diam = d;
}
public void visa(Graphics g) {
g.setColor( new Color(255,225,0) );
g.fillOval(xpos, ypos,diam, diam );
}
}
Klassen Cirkel innehåller instansvariabler för cirkelns
hörnkoordinat och diameter (sida), en konstruktor för klassen, samt
en metod visa(g) som ritar en cirkel. Fördelen med att använda
klassen Cirkel är att det förenklar om flera cirklar ska ritas, samt att
den som använder programmet VisaCirkel inte behöver förstå hur
875099958
45
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
de grafiska metoderna fungerar. Följande program VisaCirklar
ritar ut tio slumpmässigt placerade cirklar med hjälp av klassen
Cirkel ovan:
import javax.swing.*;
import java.awt.*;
public class VisaCirklar extends JPanel {
public VisaCirklar () {
this.setBackground(new Color(0,0,255));
}
public void paintComponent(Graphics g){
super.paintComponent(g);
Cirkel[] c=new Cirkel[10];
for (int i=0;i<=9;i++)
c[i]=new Cirkel((int)(200*Math.random()), (int)(200*Math.random()),60);
for (int i=0;i<=9;i++)
c[i].visa(g);
}
public static void main(String[] args) {
JFrame f = new JFrame();
f.setSize(250, 250);
f.setLocation(100,100);
f.setTitle("VisaCirklar");
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
VisaCirklar p = new VisaCirklar();
f.add(p);
f.setVisible(true);
}
}
I exemplet ovan skapas tio unika cirkelobjekt via en
vektor. Ett enklare sätt är att skriva klassen Cirkel utan
konstruktor och istället läsa in koordinaterna via visametoden. Uppgiften med gubben nedan ska göras så.
Övning 0.5.16:
Lägg till metoden visa(g, f) till klassen Cirkel, där
parametern f är ett heltal (0-3) som anger en färg: 0: röd,
1: grön, 2: gul och 3: blå. Cirkeln fylls sedan med den
färgen. Programmet skall fungera som exemplet
VisaCirklarCol.jar.
Övning 0.5.17:
Skriv en klass Gubbe som med metoden
visa(Graphics g, int x, int y, int diam) ritar ut en gubbe med
en fylld cirkel med diametern diam som huvud, samt
kropp, armar och ben med streck. Koordinaterna x och y
anger huvudets övre vänstra punkt. Kroppen har samma
längd som huvudets diameter, medan benens och
armarnas ändpunkter ligger en radie utanför kroppen i
x- och y-led. Klassen saknar konstruktor. Skriv även ett
program visaGubbe.java som med klassen Gubbe ritar
ur 10 slumpmässigt placerade gubbar med
slumpmässigt värde på diametern. Programmet skall
fungera som exemplet visagubbe.jar.
875099958
46
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Lite om animering och tangenthändelser
När vi nu kan göra grafiska
klasser och objekt är det ju roligt
om objekten även kan röra på
sig, samt om objekten kan styras
på något sätt. Med gränssnittet
KeyListener får man tillgång till
några metoder som lyssnar på
tangenterna:
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
Klickas på den röda markeringen
i vänsterkanten infogas både
ovanstående paket och följande
tre tomma tangentmetoder:
@Override
public void keyPressed(KeyEvent e) {
//Tom metod
}
@Override
public void keyReleased(KeyEvent e) {
//Tom metod
}
@Override
public void keyTyped(KeyEvent e) {
}
Med metoden e.getKeyCode() fås
tangentens kod (heltal), som för
bokstavstangenterna är ASCIIkoden för motsvarande versal.
För piltangenterna gäller
följande koder:
KeyEvent.VK_LEFT,
KeyEvent.VK_RIGHT,
KeyEvent.VK_UP och
KeyEvent.VK_DOWN.
Animeringen görs i mainmetoden med en oändlig loop
och en fördröjning. Programmet
till höger får en cirkel av klassen
Boll att stanna när den når den
högra fönsterkanten eller när
tangenten ’S’ trycks ned.
import javax.swing.*;
import java.awt.*;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
public class VisaRektangel extends JPanel implements KeyListener
{
Boll b1;
int x=200,y=400;
static int xboll=100, steg=1;
public void paintComponent(Graphics g){
super.paintComponent(g);
b1.visa(g,xboll,100);
}
public static void main(String[] args) {
JFrame f = new JFrame();
f.setSize(500, 500);
f.setLocation(100,100);
f.setTitle("Visa Rektangel");
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
VisaRektangel p = new VisaRektangel();
f.add(p);
f.setVisible(true);
f.addKeyListener(p); //Lyssnar på panelen
while (true) {
f.repaint(); //Ritar om f
xboll=xboll+steg;
if (xboll+20>=p.getWidth())
steg=0;
try {
Thread.sleep(16);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
@Override
public void keyPressed(KeyEvent e) {
int tt = e.getKeyCode();
switch (tt) {
case 'S':
x=200;
steg=0;
break;
}
}
}
Övning 0.5.18:
Skapa klassen Boll med klass-metoden visa(g,x,y), som ritar ut en grön cirkel med diametern 20
pixlar, samt kopiera in programmet VisaRektangel till höger så att det fungerar.
875099958
47
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Övning 0.5.19:
Modifiera föregående program så att det har följande
finesser:

Bollen studsar mellan fönstrets höger och
vänstersida.

Bollens fart (steglängden) ökar åt höger med Htangenten och åt vänster med V-tangenten.

Med S-tangenten stannar bollen.
Programmet skall fungera som exemplet boll.jar.
Övning 0.5.20:
Modifiera föregående program ytterligare så att bollen studsar mot alla fyra ’väggarna’. Bollen
fart uppåt (vertikalt) ökar med U-tangenten och minskat N-tangenten. Programmet skall fungera
som exemplet studsboll.jar.
Övning 0.5.21:
Modifiera föregående program ytterligare så att
bollen studsar mot den röda rektangeln som
styrs med höger- och vänsterpilen. Rektangeln
är ett objekt av klassen Rektangel och ritas med
klassmetoden visa(g,x,y). Rektangeln har måtten
50x5 pixlar. Spelet har följande finesser:

Missar rektangeln bollen så att den
studsar mot nedre kanten räknas en miss.
 Tid och missar skrivs ut i panelen
 Programmet startar på 30 s och räknar
ner till noll när det stoppas.
 Programmet kan omstartas med Stangenten.
 Bollens startläge i x-led slumpas, liksom
hastigheten (steglängden).
Programmet skall fungera som exemplet
bollspel.jar.
Övning 0.5.22:
Skriv ett program som simulerar fritt fall med studs. Accelerationen fås
genom att variera steglängden. Det ska även finnas en variabel för
studskoefficienten, d.v.s. kvoten mellan farten före och efter studs. Börja
med bollen, som anvävder klassen Boll. Lägg sedan gärna till gubben, som
använder klassen Gubbe. Programmet omstartas med en tangenttryckning.
Programmet skall fungera som exemplet frittfall.jar.
875099958
48
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Förslag på repetitionsuppgifter inför prov 2 i Programmering C (P2)
Provet omfattar kapitel 5 (Grafik, bilder och ljud), rekursion och kapitel 6 (Applets). Repetera
förslagsvis följande tidigare gjorda uppgifter:
Kapitel 5: 2.3, 2.4, 2.5, 2.7, 2.8, 0.5.1, 0.5.3, 0.5.7, 0.5.13, 0.5.14, 0.5.15, 0.5.17, 0.5.20
Kapitel 6: 3.2 (s. 73)
875099958
49
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
7. Mest om loopar och val (P1)
I detta avsnittet fördjupar vi kunskaperna från avsnitt 1 om urval och loopar. Även klassen String
tas upp. Avsnittet anknyter till kapitel 7 i Java-javisst!.
Nästlade if-satser
Vi vill ha ett program som automatiskt ger betyget när poängen på ett prov matas in. Antag att
betygsgränsernas är följande:
A: ≥30 poäng
C: ≥20 poäng
E: ≥10 poäng
Följande program med nästlade if-satser matar ut rätt betyg:
import java.util.*;
public class nastlad{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int x;
System.out.print("Ange poängen: ");
x = sc.nextInt(); //läser in heltal
if (x>=30)
System.out.print("Betyget är A");
else if (x>=20)
System.out.print("Betyget är C");
else if (x>=10)
System.out.print("Betyget är E");
else
System.out.print("Betyget är F (ej godkänd)");
}
}
Utskrift och inmatning blir då:
Ange poängen: 22
Betyget är C
Övning 0.7.1:
Skriv ett program som beräknar arean för en kvadrat, rektangel eller triangel. Programmet frågar
vilken beräkning som ska göras, enligt följande utskrifter:
Ska arean för en kvadrat (k), rektangel (r) eller triangel (t) beräknas? t
Ange bas och höjd: 5 8
Triangelns area är 20
Övning 0.7.2:
Skriv ett program som anger provbetyget för följande poänggränser:
A: ≥60 poäng
B: ≥50 poäng
C: ≥40 poäng
D: ≥30 poäng
E: ≥20 poäng
Poäng lägre än 20 ger betyget F. Programmet frågar vilken beräkning som ska göras, enligt
följande utskrifter:
Ange poängen: 32
Provbetyg: D
875099958
50
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Övning 0.7.3:
Skriv ett frågeprogram (nastlad2) med fyra frågor som låter dig fortsätta så länge du svarar rätt,
samt som räknar antal rätt svar, med följande utskrifter:
Heter tredje största stad Malmö (j/n)? j
Rätt! Antal poäng: 1
Är Sveriges högsta berg högre än 3000 m (j/n)? n
Rätt! Antal poäng: 2
Heter Värmlands högsta berg Granberget (j/n)? j
Rätt! Antal poäng: 3
Heter Sveriges tredje största sjö Hjälmaren (j/n)? n
Rätt - du vann! Antal poäng: 4
Eller:
Heter tredje största stad Malmö (j/n)? j
Rätt! Antal poäng: 1
Är Sveriges högsta berg högre än 3000 m (j/n)? j
Fel! Slutpoäng: 1
Hitta gärna på egna frågor och utöka antalet.
Jämförelseoperatorer och logiska operatorer
Olika typer av jämförelseoperatorer används bl a vid urval med if-satser. Operatorerna är
desamma som i C++:
<
>
<=
>=
==
!=
&&
||
!
Mindre än
Större än
Mindre än eller lika med
Större än eller lika med
Lika med
Inte lika med (skiljt ifrån)
Och
Eller
Icke
Sammansatta villkor
Om vi vill kolla om ett tal är större än 5 men mindre än 20 måste vi ha ett sammansatt villkor,
enligt följande programrader:
…
System.out.print("Ange ett heltal: ");
a = sc.nextInt();
if (a>5 && a<20)
System.out.print("Talet ligger mellan 5 och 20 ");
else
document.write("Talet är mindre än 5 eller större än 20");
…
875099958
51
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Övning 0.7.4:
Skriv klart programmet som kollar om ett heltal x ligger i intervallet 5 ≤ x ≤ 20, med följande
utskrifter. OCH-operator && ska användas:
Ange ett heltal x: 15
Talet ligger i intervallet
Eller:
Ange ett heltal x: 23:
Talet utanför intervallet
Övning 0.7.5:
Skriv ett program som kollar om din längd x är kortare än 160 cm eller om du är längre än 190
cm, d.v.s. om x < 160 eller x >190, med följande utskrifter. ELLER-operator || ska användas:
Ange din längd i cm: 195
Du är kortare än 160 eller längre än 195 cm
Eller:
Ange din längd i cm: 179
Din längd ligger mellan 160 och 190 cm
Övning 0.7.6:
Skriv ett program som läser in tre tal och som sedan skriver ut det största av talen. Om inget
ensamt tal är störst skrivs detta ut, med följande utskrifter:
Ange tre heltal: 7 8 3
Störst tal: 8
*Övning 0.7.7:
Skriv ett program som läser in tre heltal och som sedan skriver ut talen i storleksordning med det
minsta först, med följande utskrifter:
Ange tre heltal: 7 8 3
I ordning: 3 7 8
*Övning 0.7.8:
Skriv ett program som läser in tre heltal och som sedan kollar om något av talen är lika, alla lika
eller alla olika.
Ange tre heltal: 7 8 3
Alla olika
Eller
Ange tre heltal: 7 8 7
Två lika
Eller
Ange tre heltal: 7 7 7
Alla Lika
875099958
52
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Urval med Switch
Genomgång av Switch-satsen på sidan 7 i kapitel 7 i Java-javisst!.
Övning 0.7.9:
Skriv ett program som läser in olika heltal och som ger följande utskrifter med switch-satser:
1: Du matade in en etta.
2: Du matade in en tvåa.
3: Du matade in en trea.
Övriga heltal: Du matade in ett annat heltal. Exempel på inläsning:
Ange ett heltal mellan 1 och 3: 2
Du matade in en tvåa.
Eller
Ange ett heltal mellan 1 och 3: 7
Du matade in ett annat heltal.
Loopar
I Java finns tre typer av loopar för upprepning:



while
do
for
Vi illustrerar de tre looparna med passande uppgifter. Vi börjar med while-loopen, som vi använt
tidigare. Eftersom avbrottsvillkoret ligger före satserna som upprepas passar loopen för uppgifter
där man i förväg inte vet antal upprepningar:
double x=0;
while(x<=5){
x=x+0.02;
System.out.println("x=”+x);
}
I detta exempel skrivs x ut så länge x ≤ 5. I följande do-loop ligger avbrottskriteriet efter satserna
som upprepas, :
int i=1;
do {
i++;
System.out.println("Detta är en do-loop");
} while (i<=5);
do-loopen, som genomlöps minst en gång, används ofta i menyer. Följande for-loop används när
antal varv i loopen är känt i förväg. Här skrivs delsumman ut fem gånger:
int sum=0;
for (i=1;i<=5;i++){
sum=sum+i;
System.out.println("Summan är "+sum);
}
875099958
53
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Övning 0.7.10:
Skriv ett program som läser in en mening och som sedan skriver ut den fem gånger på egna
rader, med följande utskrift:
Ange en mening: Programmering är kul
Programmering är kul
Programmering är kul
Programmering är kul
Programmering är kul
Programmering är kul
Uppgiften ska lösas med en:
a) while-loop
b) do-loop
c) for-loop
Övning 0.7.11:
Skriv ett program som med en for-loop beräknar summan av 1+2+3+4+…+n, där n matas in.
Programmet har följande utskrifter:
Ange n: 4
Summan är 10
Övning 0.7.12:
Skriv ett program som med en for-loop beräknar produkten av 1∙2∙3∙4∙…∙n, där n matas in.
Programmet har följande utskrifter:
Ange n: 4
Produkten är 24
*Övning 0.7.13:
Talföljden 1, 1, 2, 3, 5, 8, 13, 21…är de första åtta talen i Fibonaccis talföljd. Skriv ett program
med en for-loop som beräknar det n:te fibonaccitalet med följande utskrifter:
Ange n: 7
Motsvarande fibonaccital är 13
Övning 0.7.14:
Skriv följande menystyrda program som låter dig välja mellan att addera, subtrahera,
multiplicera och dividera decimaltal. Menyn ska ligga i en do-loop och urvalen göras med
Switch-satser.
--------------------------1: Addera
2: Subtrahera
3: Multiplicera
4: Dividera
5: Avsluta
Ange en siffra: 2
Ange x och y: 8 3
Differensen är: 5.0
--------------------------1: Addera
2: Subtrahera
3: Multiplicera
4: Dividera
5: Avsluta
Ange en siffra:
875099958
54
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Datatypen boolean
Villkorssatsen i if eller while innehåller ofta villkor av typen if (x==5) eller while (x<10). Beroende
på om villkoret är sant eller falskt händer något. Villkoret har faktiskt datatypen boolean som
endast kan anta värdena true eller false. Följande rader för utskrift av fem Anders är ekvivalenta:
int i=1;
while(i<=5){
System.out.println("Anders");
i++;
}
Lite längre, men med den booelska variabeln go:
int i=0;
boolean go=true;
while(go){
System.out.println("Anders");
i++;
if (i==5)
go=false;
}
Eller något kortare utan if-sats:
int i=0;
boolean go=true;
while(go){
System.out.println("Anders");
i++;
go=i==5;
//Villkoret ger ett booelskt värde true eller false
}
De två exemplen visar hur en booelsk variabel används.
Övning 0.7.15:
Skriv ett program med en while-loop som läser in en ålder och som sedan skriver ut om du är
myndig eller inte. Programmet avbryts om du matar in siffran 0, med följande utskrifter:
Ange din ålder (avsluta med 0): 3
Du är inte myndig.
Ange din ålder (avsluta med 0): 19
Du är myndig.
Ange din ålder (avsluta med 0): 0
Programmet avslutat!
Lös uppgiften med:
a) Med åldern i while-villkoret.
b) Med en booelsk variabel i while-villkoret.
875099958
55
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Övning 0.7.16:
Skriv ett program som beräknar summan av två tal och som sedan frågar om en ny beräkning ska
göras, med följande utskrift.
Skriv ett tal: 4
Skriv ett tal till: 6
Summan är 10
Ny beräkning? j
Skriv ett tal: 4
Skriv ett tal till: 2
Summan är 6
Skriv ett tal: 6
Antal inmatade tal: 1
Summan är 6.0
Största talet är 6
Minsta talet är 6
Medelvärdet är 6.0
Ny beräkning? N
OK – hej då!
Lös programmet med en do-loop.
Radframmatning görs med "\n" i
Skriv ett tal: 3
Antal inmatade tal: 2
Summan är 9.0
Största talet är 6
Minsta talet är 3
Medelvärdet är 4.5
System.out.println.
Övning 0.7.17:
Skriv ett program som läser in heltal > 0 och
som skriver ut antal inmatade tal, summan av
talen som matats in, största och minsta talet,
samt medelvärdet av de inmatade talen.
Inmatningen avbryts när talet 0 matas in.
Programmet har utskrifterna till höger. Lös
uppgiften på följande sätt:
a) Skriv ett program som läser in heltal tills
talet 0 matas in. Då skrivs ”Slut!” ut.
Använd en do-loop.
b) Skriv ut antalet inmatade tal.
c) Skriv ut summan av de inmatade talen.
d) Skriv ut det största inmatade talet.
e) Skriv ut det minsta inmatade talet.
f) Skriv ut medelvärdet av de inmatade talen.
Även en radframmatning ska göras efteråt.
875099958
56
Skriv ett tal: 10
Antal inmatade tal: 3
Summan är 19.0
Största talet är 10
Minsta talet är 3
Medelvärdet är
6.333333333333333
Skriv ett tal: 3
Antal inmatade tal: 4
Summan är 22.0
Största talet är 10
Minsta talet är 3
Medelvärdet är 5.5
Skriv ett tal: 0
Slut!
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
9. Arrayer, sortering och strängar
Hittills har vi deklarerat en ny variabel för varje tal eller tecken
som lagras i våra program. Ska programmet hantera många
variabler är det mer praktiskt att deklarera en array, som i princip
kan lagra hur många värden (tal, tecken eller strängar) som helst.
I detta kapitlet ska vi först lära oss att hantera arrayer, som även
kallas vektorer och fält, och sedan använda dem för att sortera
stora mängder tal och strängar.
Array
Antag att vi vill lagra fyra heltal i ett program. Hittills har vi gjort detta genom att deklarera fyra
heltalsvariabler:
int t1, t2, t3, t4;
Ett enklare sätt är att lagra dem är i en array, som kan liknas vid en byrå med många lådor som är
numrerade från 0, 1, 2,… Numren kallas ’lådans’ index. Eftersom varje index (låda) motsvarar
ett heltal (eller ett tecken, sträng…) kallas en array för en indexerad variabel. En array x kan
initieras på två sätt i Java:
int[] x={100, 200, 255, 187}; //Kallas hakparenteser och klamrar, krullparanteser eller måsvingar.
Eller så här:
index: 0
int[] x=new int[4]; //Anger antalet tal i arrayen.
x[0]=100;
//Det första indexet är alltid noll.
x[1]=200;
x[2]=285;
x[3]=187;
x:
100
1
2
3
200
285
187
Följande program läser in fem heltal och skriver sedan ut talen på en rad utan mellanslag:
import java.util.Scanner;
public class avrundning {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int[] x = new int[5];
System.out.println("Ange fem heltal:");
for (int i = 0; i <= 4; i++)
x[i] = sc.nextInt();
for (int i = 0; i <= 4; i++)
System.out.print(x[i]);
}
}
Med utskriften:
Ange fem heltal:
3
5
2
1
6
35216
875099958
57
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Övning 0.9.1:
Kopiera och modifiera exemplet ovan som läser in fem heltal så att det får följande utskrifter:
Ange fem heltal:
Ange tal 1: 2
Ange tal 2: 7
Ange tal 3: 9
Ange tal 4: 23
Ange tal 5: 12
Du matade in följande tal:
Tal 1=2
Tal 2=7
Tal 3=928
Tal 4=23
Tal 5=12
Övning 0.9.2:
Modifiera föregående program så att det går att läsa in och skriva ut decimaltal.
Övning 0.9.3:
Modifiera föregående program så att det går att läsa in och skriva ut tecken:
Ange fem tecken:
Ange tecken 1: t
Ange tecken 2: q
Ange tecken 3: w
Ange tecken 4: b
Ange tecken 5: h
Tecken 1=t
Tecken 2=q
Tecken 3=w
Tecken 4=b
Tecken 5=h
Övning 0.9.4:
Modifiera föregående program så att det går att läsa in och skriva ut strängar:
Ange fem meningar:
Ange en mening 1: Verbet gör något.
Ange en mening 2: Adjektiv är något.
Ange en mening 3: Substantiv är namn.
Ange en mening 4: Predikat är vad som händer.
Ange en mening 5: Subjekt är vem som händer.
Mening 1: Verbet gör något.
Mening 2: Adjektiv är något.
Mening 3: Substantiv är namn.
Mening 4: Predikat är vad som händer.
Mening 5: Subjekt är vem som händer.
Övning 0.9.5:
Skriv ett program som genererar 4 slumptal mellan 0 och 1. Samma slumptal ska sedan användas
för att beräkna 4 hela slumptal mellan 0 och 10, respektive mellan 1 och 6, med följande
utskrifter:
0-1: 0.8806355145001596 0.322825002066638 0.6216970739588585 0.3003654222227192
0-10: 9 3 6 3
1-6: 6 2 4 2
875099958
58
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
*Övning 0.9.6:
Du ska nu skriva ett program Minnestest.java som slumpar sex heltal mellan 1 och 9. Efter att
talen visats i fem sekunder försvinner de från konsolen, d.v.s. matas fram 25 rader, och du ska
komma ihåg dem och mata in dem med enter-tangenten. Efter att det sista talet matats in jämförs
de slumpade med de inmatade talen för att kolla om du matat in rätt tal. Utskrifterna är följande:
9 5 5 1 1 2 (Visas i 5 sekunder)
Mata in talen med Enter emellan!
9
5
5
1
1
2
Rätt svar :)
Alternativt:
Fel svar :(
Rätt svar: 9 5 5 1 1 2
En fördröjning på fem sekunder (5000 ms) åstadkomms med följande program Minnestest:
public class Minnestest {
public static void main(String[] args) throws Exception {
System.out.println("Vänta!");
Thread.sleep(5000);
System.out.print("Nu har det gått tre sekunder");
}
}
Kopiera och provkör programmet med fördröjningen. Lös sedan uppgiften genom att modifiera
programmet. Öka gärna till fler än sex tal att komma ihåg.
Övning 0.9.7:
Föregående övning förenklas något om följande färdiga metod för att jämföra de två vektorer a
och b används:
Arrays.equals(a,b)
Är vekorerna lika har metoden värdet true, annars false. Den färdiga klassen Arrays finns i
paketet import java.util.Arrays. Gör ändringen och provkör.
Övning 0.9.8:
Även objekt som knappar (JButton) kan läggas i en array. Skriv ett
program som skapar tio knappar och en label. När en knapp klickas
skrivs knappens nummer ut i labeln, enligt exemplet knappar2.jar.
Knapparna skapas som vektorobjekt med följande
referensdeklaration…
JButton b[]=new JButton[10];
… i början av programmet. I programmets konstruktor skapas de
fem knappobjekten med satsen:
for (int i=0;i<=9;i++)
b[i] = new JButton("Knapp "+i);
Skriv även koden för utskriften i metoden
actionPerformed(ActionEvent e).
875099958
59
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Programmets lösning visas på följande sida, utan de importerade paketen:
public class Knappar extends JFrame implements ActionListener {
JButton b[] = new JButton[10];
JLabel lbl;
String namn;
public Knappar() {
this.setLayout(new FlowLayout());
lbl = new JLabel("Detta är en JLabel!");
for (int i = 0; i <= 9; i++)
b[i] = new JButton("Knapp " + i);
for (int i = 0; i <= 9; i++) {
add(b[i]);
b[i].addActionListener(this);
}
add(lbl);
}
public void actionPerformed(ActionEvent e) {
for (int i = 0; i <= 9; i++)
if (e.getSource() == b[i])
lbl.setText("Du klickade på knapp " + i);
}
public static void main(String[] args) {
Knappar f = new Knappar();
f.setSize(200, 250);
f.setLocation(100, 100);
f.setTitle("Knappar");
f.setDefaultCloseOperation(Knappar.EXIT_ON_CLOSE);
f.setVisible(true);
}
}
Övning 0.9.9:
Nu ska föregående uppgift modifieras så att bakgrundsfärgen
ändras via fem knappar, enligt exemplet knappfarg.jar. För att
framens bakgrundsfärg ska kunna ändra måste följande variabel
deklareras som en global klassvariabel:
static Container fc;
I main-metoden får variabeln sitt värde:
fc = f.getContentPane();
Det inledande ordet static måste anges eftersom variablen finns
med i main-metoden, som exekveras först när programmet
startas. Färgen ändras sedan i actionPerformed-metoden med
följande sats:
fc.setBackground(Color.yellow);
875099958
60
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Sortering
Vi har tidigare (kapitel 7) sorterat tal i storleksordning och namn i bokstavsordning. Om ni
minns så var det ganska krångligt att göra det med endast tre tal eller namn. När vi nu skall
sortera fem och kanske hundra tal måste vi därför använda oss av en vektor och en enkel
sorteringsalgoritm. Följande algoritm, kallad bubbelsort, sorterar här innehållet i heltalvektorn
x[i] med fem heltal i stigande ordning:
for (int i = 0; i <= 3; i++) {
for (int j = i + 1; j <= 4; j++) {
if (x[i] > x[j]) {
temp = x[i];
x[i] = x[j];
x[j] = temp;
}
}
}
Den klassiska bubbelsort-algoritmen fungerar på följande sätt:
1. Vektorns första tal (i=0) järmförs med med de övriga talen i vektorn från indexet i=1 till
det största indexet.
2. Om det första talet är större vid en jämförelse byts talen.
3. När det första talet jämförts med alla talen ligger det minsta talet först i vektorn.
4. Därefter jämförs det andra talet (i=1) i vektorn med de övrigs talen i vektorn från indexet
i=2 till det största indexet.
5. När vektorns andra tal jämförts med de övriga talen ligger det näst lägsta talet i vektorns
andra position.
6. När processen ovan upprepats för de övriga talen ligger talen sorterade i vektorn med det
lägsta först och högsta sist.
Algoritmen fungerar även för decimaltal och strängar.
Övning 0.9.10:
Skriv med hjälp av sorteringsalgoritmen ovan programmet Sortering.java som genererar fem
slumptal mellan 1 och 10 och som skriver ut slumptalen både osorterasde och sorterade, med
följande utskrift:
Slumptal: 1 8 3 7 8
Sorterade: 1 3 7 8 8
Övning 0.9.11:
Modifiera programmet så att tio slumptal mellan 1 och 10 skrivs ut osorterade och sorterade med
följande utskrift:
Slumptal: 9 1 10 2 9 5 7 1 5 3
Sorterade: 1 1 2 3 5 5 7 9 9 10
875099958
61
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Mer om strängar
Vi har tidigare använt strängar (datatypen String). För att kunna sortera strängar (exempelvis
namn), måste vi dock känna till följande metoder för strängar:
str.length()
str.charAt(n)
str.compareTo(str2)
//ger antalet tecken i str
//ger tecknet i position n
//ger 0 om str = str2 , <0 om str kommer före str2, annars >0
Det går attså inte att jämföra två strängar med olikstecken (<, > eller =). I kapitel 1 nedan finns
fler metoder för strängar.
Övning 0.9.12:
Skriv ett program Stringrader.java som läser in ett ord och som sedan skriver ut bokstäverna på
egna rader:
Ange ett namn: kalle
k
a
l
l
e
Övning 0.9.13:
Skriv ett program som läser in två namn och som skriver ut namen i stigande bokstavsordning,
med följande utskrift:
Ange ett namn: kalle
Ange ett namn till: anders
I stigande ordning: anders kalle
Övning 0.9.14:
Skriv ett program som läser in fem namn och som skriver ut namen i stigande bokstavsordning,
med följande utskrift:
Hur många namn ska matas in: 4
Ange namn 1: kalle
Ange namn 2: eva
Ange namn 3: anna
Ange namn 4: linda
I bokstavsordning:
anna eva kalle linda
875099958
62
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
13. Animering och trådar
Här bygger vi vidare på animeringar, som vi berörde i kapitel 5. I slutet på kapitlet kommer vi
även att animera med trådar. Innehållet bygger på kapitel 13 i Java-javisst!.
Timer
En timer är här klassen Timer(tid, this) som i konstruktorn anropar metoden
actionPerformed(ActionEvent e) upprepade gånger efter en viss angiven tid i millisekunder.
Klassen har även metoderna start() och stop() för att starta respektive stoppa timern. Följande
kod flyttar en fyrkant över skärmen. Kopiera och kör den!
import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.Timer;
public class Fyrkant extends JPanel implements ActionListener {
Timer t;
//t är referens till klassen Timer
int x=10, y=10;
public Fyrkant() {
t= new Timer(100,this); //Ett nytt Timer-objekt t skapas, som anropar metoden
t.start();
//actionPerformed var 100:e millisekund. Startas här.
setBackground(Color.white);
}
public void paintComponent(Graphics g) {
super.paintComponent(g);
//Vad händer om super.paintComponent kommenteras bort?
//g.setColor(Color.cyan);
x++;
y++;
g.fillRect(x, y, 30, 30);
}
public void actionPerformed(ActionEvent e) {
repaint();
}
public static void main(String[] args) {
JFrame f = new JFrame();
f.setSize(200, 220);
f.setLocation(100, 100);
f.setTitle("Fyrkant");
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Fyrkant p = new Fyrkant();
f.add(p);
f.setVisible(true);
}
}
Övning 0.13.1:
Gör projektmappen kap13 i Eclipse och ladda ner de sex elefantbilderna från
hemsidan för Java-javisst! dit. Gör/kopiera sedan programmet JumboFilm.java
på s.4 som ’animerar’ elefantens rörelse när knappen klickas. Programmet ska
fungera som exemplet JumboFilm.jar. För att jar-filen ska fungera måste den
875099958
63
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
laddas ned till en mapp där de sex elefantbilderna finns.
Övning 0.13.2:
Kopiera föregående program och klistra in det under namnet
JumboFilm2.java. Elefanten ska nu röra sig när markören flyttar sig
över panelen. Detta görs med gränssnittet MouseMotionListener och
genom att lägga mousemotion-lyssnaren på panelytan med koden
addMouseMotionListener(this), samt ’klicka in’ metoderna
mouseMoved() och mouseDragged() och skriva in satsen repaint() i
mouseMoved(). Programmet ska fungera som exemplet
JumboFilm2.jar. Ta gärna bort knappen.
Övning 0.13.3:
Du ska nu skriva ett program så att elefanten
tycks röra sig utan att knappen klickas. Detta
åstadkoms med en Timer. Kopiera åter första
övningen och klistra in den under namnet
JumboFilmTimer.java, och modifiera den
enligt koden på s. 5. Programmet ska fungera
som exemplet JumboFilmTimer.jar. Ta gärna
bort knappen.
Övning 0.13.4:
Modifiera föregående program så att elefantens rörelse kan stoppas och
startas med en knapp, samt att dess fart kan ökas och minskas med två
knappar, enligt urklippet till höger. Uppritningshastigheten ändras med
fördröjningsmetoden t.setDelay(tid). Programmet ska fungera som
exemplet JumboFilmTimerKnapp.jar. Observera att knapptexten
Starta/Stopp ändrar sig när knappen klickas, vilket görs med metoden
butt.setText("Stopp").
Övning 0.13.5:
Skriv ett program som ritar en slumpmässig linje (myrans
vandring), enligt exemplet Myran.jar. Rörelsen är
slumpmässig uppåt, neråt, till vänster och höger och ritas
från föregående linjes slutkoordinat. Linjen får inte ’rymma’
utanför ritytan. Timerns anropstid är 100 ms och ritytan har
måtten 200 x 200 pixlar. Vad händer om den överskuggade
(override) metoden super.paintComponent(g) kommenteras
bort?
Övning 0.13.6:
Modifiera föregående
övning så att en
elefant (jumbo0.gif)
rör sig slumpmässigt,
enligt exemplet
Elefanten.jar.
875099958
64
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Övning 0.13.7:
Gör ett program som simulerar en
sekundvisare på en klocka, enligt
exemplet klockan.jar.
Sekundvisaren ska alltså gå ett
varv på 60 sekunder. Förse
urtavlan med siffrorna 1-12
omedelbart utanför cirkeln, samt
med en något kortare minutvisare
som rör sig på lämpligt sätt.
Övning 0.13.8:
Modifiera föregående
program så att klockan även
har en minutvisare, samt
gradering för timmarna,
enligt exemplet klocka2.jar.
I en senare övning gör vi om
detta programmet till en
egen klasss.
875099958
65
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Klasser och Timer
I första programexemplet ovan flyttades en svart
kvadrat diagonalt över panelen. Vi vill nu flytta
ytterligare en kvadrat, men med en annan färg
och hastighet. Då är det lämpligt att göra om
programmet till en klass med instansvariabler för
färg, och uppritningstid. Vi vill även att
uppritningen ska börja i olika koordinater. För att
åstadkomma detta gör vi en metod som anger
startpunktens x- och y-koordinat. Här är klassen
Fyrkantklass.java för en kvadrat:
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JPanel;
import javax.swing.Timer;
public class Fyrkantklass extends JPanel implements ActionListener {
private Timer t;
private int x, y, diam, tid;
private Color farg;
public Fyrkantklass(int panelbredd, Color f, int timetid) {
diam = panelbredd;
farg = f;
tid = timetid;
t = new Timer(tid, this);
t.start();
setBackground(Color.white);
this.setPreferredSize(new Dimension(diam, diam)); //Anger panelens storlek
}
public void set_xy(int xstart, int ystart) {
x = xstart;
y = ystart;
}
public void paintComponent(Graphics g) {
super.paintComponent(g);
g.setColor(farg);
x++;
y++;
g.fillRect(x, y, 20, 20);
}
public void actionPerformed(ActionEvent e) {
repaint();
}
}
Programmet som skapar två objekt av klassen Fyrkantklass visas nedan. Observera att varje
objekt adderas till programmets panel liksom knappar och och textrutor, men att kvadraternas
koordinater anges relativt deras egna paneler:
875099958
66
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
import java.awt.*;
import javax.swing.*;
public class Program_fyrkant extends JPanel {
private Fyrkantklass k1, k2;
public Program_fyrkant() {
k1 = new Fyrkantklass(50, Color.green, 100);
k2 = new Fyrkantklass(100, Color.red, 200);
k1.set_xy(0, 0);
k2.set_xy(0, 30);
add(k1);
add(k2);
}
public static void main(String[] args) {
JFrame fr = new JFrame();
fr.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
fr.setSize(300, 200);
fr.setLocation(100, 100);
fr.setTitle("Program_fyrkant");
Program_fyrkant gr = new Program_fyrkant();
fr.add(gr);
fr.setVisible(true);
}
}
Övning 0.13.9:
Skapa klasssen
Elefantklass.java(tid)
av programmet i
uppgift 0.13.3.
Konstruktorn ska ha
parametrar för
elefantens
gånghastighet och
färgen på den
bakomliggande cirkeln. Skapa sedan programmet Elefantprogram.java som ritar upp 3
elefanter med olika gånghastigheter och färger.
Övning 0.13.10:
Skapa klasssen
Klock_klass.java av
programmet i uppgift 0.13.8.
Konstruktorn ska ha
parametrar för klockan
gånghastighet och färgen på
den bakomliggande cirkeln.
Skapa sedan programmet
Klockprogram.java, som ritar
upp 4 klockor med olika
gånghastigheter, enligt
exemplet klockprogram.jar.
875099958
67
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Datorns tid
Nu ska vi bli lite modernare och göra en digital klocka. Den första klockan använder sig av
datorns tid med hjälp av Calender-metoden (se Javajavisst! kapitel 8):
String tiden = Calendar.getInstance().getTime().toString();
Följande String-metod ’klipper ut’ positionerna start till slut (ingår ej!) av strängen tiden:
kalle = tiden.substring(start, slut);
Om exempelvis strängen tiden=“andersson” och start=2 och slut=5 får strängen kalla värdet
”der”. Den andra digitala klocka skapar vi med egna lablar.
Övning 0.13.11:
Kopiera klassen Digitalur.java på sidan 11 i Javajavisst! kapitel 13, vilken ärver egenskaper
från JLabel. Modifiera konstruktorn så att den får fler parametrar:
Digitalur(Color farg1, Color farg2, int fontsize, int start_pos, int slut_pos)
Parametrarna start_pos och slut_pos anger
start- och slutposition för datorna
tidsangivelse med Calender-metoden ovan.
Skapa sedan klassen Digitalprogram.java
genom att kopiera och modifiera
Klockprogram.java ovan. Skapa sedan fyra
objekt för tidsangivelser med följande
konstruktoranrop:
k1 = new Digitalur(Color.red,Color.yellow,10,0,29);
k2 = new Digitalur(Color.yellow,Color.blue,20,5,29);
k3 = new Digitalur(Color.yellow,Color.blue,40,0,19);
k4 = new Digitalur(Color.black,Color.white,60,11,19);
Det färdiga programmet fungerar som Digitalprogram.jar.
Övning 0.13.12:
Nu ska du skapa en digital klocka som skriver ut
timmar, minuter, sekunder, tiondelar och
hundradelar, enligt urklippet till höger och som
fungerar som Digitalklocka.jar. Skapa klassen
Digitalklass.java genom att kopiera och
modifiera klassen Digitalur.java i förra
uppgiften. Använd här en vanlig Timer som vi använt tidigare. Beräkna timmarna, minuterna,
sekunderna och tiondelarna genom att tillämpa heltalsdivision och begreppet modulus (%) på
hundradelarna. Konstruktorn har följande inparametrar:
Digitalklass(Color farg, int fontsize, int h, int min, int sek)
Parametrarna h, min och sek är klockans starttid i timmar, minuter och sekunder. Skriv även
programmet Digitalklocka.java som anropar Digitalklass.java. Urklippet ovan är skapat med
följande tre objekt (hur många sekunder gick det innan skärmdumpen gjordes?):
k1 = new Digitalklass(Color.red,20,2,20,30);
k2 = new Digitalklass(Color.black,50,12,37,43);
k3 = new Digitalklass(Color.blue,100,0,0,0);
875099958
68
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Grafik och animering
I animeringarna vi hittills gjort i detta kapitel har timerobjektet legat i en klass och
animeringarna har varit varit av varandra oberoende objekt som skapats i programmet i form av
exempelvis animerade elefanter eller klockor. Vill vi skapa många föremål som på något sätt rör
sig i förhållnade till varandra är de lämpligt att lägga timerobjektet i programmet. Föremålen kan
dock vara egna klasser. Följande klass Cirkel.java ritar ut en cirkel:
public class Cirkel {
private int xpos, ypos, diam, dx = 6, dy = 2;
public Cirkel(int x, int y, int d) { //Skapar cirkel i koord x och y med diameter d
xpos = x;
ypos = y;
diam = d;
}
public void visa(Graphics g) { //Ritar ut cirkel
g.setColor(Color.red);
g.fillOval(xpos, ypos, diam, diam);
}
public void nyPosition() { //Ändrar cirkelns position dx och dy
xpos = xpos + dx;
if (xpos + diam + 20 > 300 || xpos < 0)
dx = -dx;
ypos = ypos + dy;
if (ypos > 300) // y börjar om när det är > 300.
ypos = -diam;
}
}
I följande program Animera_cirkel.java skapas ett objekt av klassen Cirkel och animeras av
timerobjektet. Av utrymmesskäl utelämpas importerade paket:
public class Animera_cirkel extends JPanel implements ActionListener {
Cirkel c = new Cirkel(20,20,50); // Referens till array med 10 asteroider
Timer t;
public Animera_cirkel() {
setBackground(Color.black);
t = new Timer(30, this);
t.start();
}
public void paintComponent(Graphics g) {
super.paintComponent(g);
c.visa(g); // Ritar ut asteroiderna
}
public void actionPerformed(ActionEvent arg0) { //Anropas av Timer
c.nyPosition();
//Ger asteroiderna ny position
repaint();
//Ritar om via paintComponent
}
public static void main(String[] args) {
JFrame f = new JFrame();
f.setSize(300, 300);
f.setLocation(100, 100);
f.setTitle("Visa_cirkel");
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Animera_cirkel p = new Animera_cirkel();
f.add(p);
f.setVisible(true);
}
}
875099958
69
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Övning 0.13.13:
I exemplet ovan kommer det fram en ny cirkel upptill när den andra försvinner nedtill. Modifiera
programmet så att cirkeln även studsar mot den nedre och övre kanten, enligt exemplet
Animera_cirkel.jar.
Övning 0.13.14:
Modifiera föregående klass Cirkel.java så att cirkeln startar i en slumpad koordinat (1-240), har
slumpmässig diameter (5-50) och en slumpmässig färg. Konstruktorn Cirkel() anropas alltså från
programmet Animera_cirkel.java utan parametrar, eftersom dessa nu slumpas i Cirkel.java.
Programmet fungerar enligt exemplet
Animera_cirkel2.jar.
Övning 0.13.15:
Modifiera föregående program Animera_cirkel.java
så att det ritar ut fem cirklar, enligt exemplet
Animera_cirkel3.jar. Cirklarna skapas som
vektorobjekt med följande referensdeklaration…
Cirkel c[] = new Cirkel[5];
… i början av programmet. I programmets konstruktor
skapas de fem cirkelobjekten med satsen:
for (int i = 0; i <= 4; i++)
c[i] = new Cirkel();
Modifiera metoderna paintComponent och
actionPerformed så att de fem cirklarna
ritas ut.
Övning 0.13.16:
Vi ska nu göra astroidspelet i Javajavisst
kapitel 13 som börjar med övningen
Astroiderna rör sig på sidan 7. Kopiera
de existerande filerna Asteroid.java och
VisaAsteroider.java från Javajavisst
kapitel 5 sidan 23 respektive kapitel 9
sidan 23 och klistra in dem i projektet
kap13. Gör sedan modifieringarna på
sidorna 7 och 8 så att programmet
fungerar som exemplet
VisaAsteroider.jar.
Övning 0.13.17:
Vi ska nu göra ett rymdskepp med laserfunktion.
Kopiera klasserna Rymdskepp.java och
VisaRymdskepp.java i kapitel 9. Modifiera sedan
klasserna enligt sidan 19 kapitel 11 så att rymdskeppet
går att flytta i sidled med vänster och höger piltangent.
När mellanslagstangenten trycks ned avfyras en
laserstråle, enligt exemplet VisaRymdskepp.jar. Glöm
inte att lägga f.addKeyListener(p) i main-metoden.
875099958
70
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Övning 0.13.18:
Nu ska du göra ett spel som med rymdskeppet från
förra övningen som skjuter ned astroidern i den
förförra övningen. Skapa programmet
Astroidspel.java genom att kopiera och byta namn
på VisaAsteroider.java. Infoga även koden från
programmet VisaRymdskepp.java så att
programmet Astroidspel.java både visar de fallande
asteroiderna och hanterar rymdskeppet och
laserkanonen med tangenterna. Programmet
använder klasserna Rymdskepp.java och
Asteroid.java. Lös nu uppgiften enligt följande
punkter:

Modifiera programmet och klasserna enligt sidan 14 i JavaJavisstPlus kapitel 13.

Modifiera programmet så att att tiden och antal kvarvarande asteroider skrivs ut.

När alla tio asteroiderna är nedskjutna stannar tiden och det står Slut!.

När laserkanonen avfyras hörs ett ljud, liksom när en asteroid träffas. Ljudfilerna
laser.au och traff.au finns på Javajavists hemsida http://www.sectordata.se/laromedel/index.php
Programmet fungerar enligt exemplet Asteroidspel.jar. För att ljudeffekterna ska höras måste jarfilen ligga i samma mapp som de båda ljudfilerna ovan.
Mushändelser
Nedan löser vi att några grafikuppgifter där mushändelser används. Vi inleder därför med att
kolla hur följande sju mushändelser fungerar:
mousePressed, mouseClicked, mouseReleased, mouseEntered, mouseExited, mouseDragged,
mouseMoved
Övning 0.13.19:
På sidan 7 i kapitel 11 i Javajavisst finns programmet
Mustest2.java, som illustrerar mushändelserna ovan. Kopiera
och impementera koden i Eclipse och ändra den så att
programmet fungerar som exemplet Mustest.jar, enligt följande:

Samma text skrivs ut i labeln som i grafiktexten.

Texten anger marköresns koordinat.

När en musknapp klickas flyttas grafiktexten till
markören.

Hålls en musknapp intryckt flyttas grafiktexten med markören.

Kommer markören in på labeln anger texten detta.

Lämnar makören panelen anger texten detta.
875099958
71
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Övning 0.13.20:
Nu ska vi skriva ett program som spränger
ballonger med musknappen genom att
modifiera programmet
Animera_cirkel.java och dess klass
Cirkel.java. Kopiera först både dessa filer
och klistra in dem som Klicka_cirkel.java
respektive Cirkel3.java. Från programmet
Astroidspel.java kan sättet att kolla
träffar, utskrifter och koden för ljudet vid
träff återanvändas. Använd musmetoden
mousePressed för att klicka på ballongerna
och registrera koordinaten. Observera att
två gränssnitt måste implementeras:
public class Klicka_cirkel extends JPanel implements ActionListener, MouseListener {…
Programmet fungerar som exemplet Klicka_cirkel.jar. Förslag till lösningar till de båda klasserna
finns längst ner i detta dokumentet.
Övning 0.13.21:
Här ska du skriva ett program med med många
kompassnålar som med sin nordände pekar mot
markören när den rör sig och musknappen är nedtryckt,
enligt exemplet Kompass_program.jar. Lös förslagsvis
programmet enligt nedanstående punkter:

Skapa programmet Kompass_program.java.

Konstruera en kompasspil i form av två streck,
ett rött och ett vitt.

Lägg kompassnålens mittpunkt i koordinaten
(x0, y0).

Gör så att kompassens röda del pekar mot koordinaten (x, y). Använd likformighet för att
räkna ut till vilka koordinater de det röda och vita strecket ska ritas. Kompassnålens
totala längd är 60 pixlar.

När programmet startas pekar kompassnålen mot origo, alltså övre vänstra hörnet.

När musknappen trycks ned och rör sig ska kompassnålens röda del peka mot markören.

Modifiera nu programmet och skapa klassen Kompass_klass.java, som ritar upp
kompassnålen som skapas i programmet Kompass_program.java. Klasen har inga
parametrar. Ritningen av kompassen görs med metoden visa(g,x,y), där x och y är
markörens koordinat.

Skapa slutligen en vektor med 20 kompassnålar som alla pekar mot markören när
musknappen är nedtryckt. I början pekar alla nordändar mot origo.
875099958
72
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
18. Appar för Android
Smartphones blir vanligare och ersätter allt oftare datorer. Bortsett från att de är lätta och
portabla är nog det främsta skälet till populariteten den lavinartade framväxten och
användningen av appar, d.v.s. mobilapplikationprogram för nästan vad som helst som kan laddas
ner till telefonen. I denna kursen kommer vi att lära oss grunderna i att göra appar för Googles
mobila operativsystem Android, som tillsammans med Apples operativsystem iOS är de mest
spridda plattformarna för appar. Android har fördelen att Java och Eclipse används för att göra
apparna, samt att det är billigare (engångskostnad $25) att lägga ut apparna för nedladdning på
Google Play (tidigare Andriod Market) jämfört med på
Apples App Store ($99/år). I denna kursen görs apparna
för Android. Kursen förljer till stora delar kapitel 18 i
Java-javisst!
Installation av verktyg
För att kunna göra apparna måste vi ha följande verktyg – program:

Android Software Development Kit (SDK) – program för utveckling av appar i Java.
Fordrar JDK6 eller 7 och en sen variant av Eclipse.

Android Development Tools (ADT) – ett pluginprogram för Eclipse.

Android Virtual Device (AVD) – en virtuell, simulerad, emulerad telefon på datorskärmen
där apparna kan köras. Typ av telefon (Nexus s15) väljs vid installationen. Spelar dock
ingen roll vilken telefon som väljs.

Testa apparna på din androidtelefon
I kapitel 21 i Java-javisst! beskrivs utförligt hur ovanstående fyra installationer görs, vilket tar
omkring en timme. Och här är den officiella sidan för apputvecklare:
http://developer.android.com/index.html
Övning 0.18.1:
Kolla vilka AVD:er som är installerade på din dator genom att i Eclipse kolla detta i menyvalet
Window/Android Virtual Device Manager.
875099958
73
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Androidprojekt
Ett Androidprojekt består av tre delar:

Application name – appnamnet som användares ser, ungefär som taggen Title i html-sidor.

Project name – namnet på mappen med projektfilerna, ungefär som i Java.

Package name – ett unikt namn för varje app, ofta företagets webbadress baklänges,
exempelvis för www.andersandersson.nu blir det nu.andersandersson.minapp, om appen har
namnet minapp.
Androidprojektet består av tre filer. Om Package name ges namnet com.example.andtest1
erhålls följande filer:

Andtest1.java: innehåller javakoden för appen och körs som en javafil i Eclipse. Filens
sökväg är: AndroidProjekt1/src/com/example/andtest1/Andtest1.java

activity_andtest1.xml: innehållr beskrivningen av sidans layout, dels grafiskt, dels med
xml-kod. I grafikläget kan denna filen layoutas med komponenter (label, textruta och
knapp), typsnitt och bakgrundsfärger.
Filens sökväg är: AndroidProjekt1/res/layout/activity_andtest1.xml

strings.xml:
innehåller värdena
för olika
komponenterna
(label, textruta och
knapp) och färger
med xmlformatering.
<?xml version="1.0" encoding="utf-8"?>
<resources>
<string name="app_name">Android test 1</string>
<string name="hello_world">Hej Världen, Anders!</string>
<string name="menu_settings">Settings</string>
<string name="mitt_namn">Jag heter Ville</string>
<string name="alder">Jag är 19 år</string>
<string name="ort">Jag bor i Skoghall</string>
<color name="blue">#0000FF</color>
<color name="yellow">#FFFF00</color>
</resources>
Om Androidprojektet ges namet AndroidProjekt1 och Package-namnet (exempelvis
com.example.andtest1) slutar på andtest1, får de tre filerna följande sökvägar i Eclipse
mappstruktur:

AndroidProjekt1/src/com/example/andtest1/Andtest1.java

AndroidProjekt1/res/layout/activity_andtest1.xml

AndroidProjekt1/res/values/strings.xml
Övning 0.18.2:
Skapa ett nytt Androidprojekt i Eclipse via menyvalet File/New/Android Application Project
alternativt File/New/Project, i fönstret New Project expandera Android och klicka Android
Application Project. Följ sedan anvisningarn på sidan 3 i kapitel 21 i Java-javisst!
875099958
74
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Övning 0.18.3:
Lägg till raderna i filen string.xml, enligt urklippet ovan. I nästa uppgift ska detta används för att
formatera sidan.
TextView, typsnitt, färger och bakgrundsbild
Komponenten TextView i Android motsvarar en textlabel i java. I detta avsnitt ska vi formatera
text och hatera färger. Observera att text- och färgelementens namn, samt text och färger lagras i
filen strings.xml.
Övning 0.18.4:
Gå till grafikläget i filen
activity_andtest1.xml och för följande
inställningar med hjälp av kapitel 18 t.o.m
sidan 14 i Java-javisst!:
a) Lägg in en TextView genom att dra den
från lagret till vänster in till skärmytan,
samt infoga texten Hej Världen, Anders!
från filen string.xml. Texten är kursiv, har
storleken 30 dpi och är gul (från filen
string.xml).
b) Lägg in ytterligare en TextView, infoga
texten Jag heter Ville från filen
string.xml. Texten har stoleken 30 dpi och
har seriffer (vid Typeface).
c) Lägg in ytterliggare en TextView och
infoga namnet jag är 19 år från filen
string.xml. Texten har storleken 20 dpi.
d) Prova att lägga i en blå bakgrundsfärg
(från filen string.xml). Bakgrunds
e) Lägg in en bakgrundsbild. Välj en egen bild att lägga in eller en bil från Java-javisst!
875099958
75
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Händelsehantering – via ett exempel
Skapa app-projektet namnrutor som läser in för- och efternam i två rutor och sedan skriver ut
namnen i en TextView när en knapp klickas. Knapparna Röd och Grön ger röd respektive grön
bakgrund, medan knappen Vit+24p+gul ger vit bakgrund, textstorlek 24p och gul text. Lösning:
package com.example.namnrutor;
import android.app.Activity;
import android.graphics.Color;
import android.os.Bundle;
import android.view.Menu;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.RelativeLayout;
import android.widget.TextView;
//Ctrl-Shift-o infogar nödvändiga bibliotek
public class MainActivity extends Activity implements OnClickListener {
private String f,e;
//Här deklareras variabler och objekt
private EditText tf,te;
private TextView lbl;
private Button b4,b3;
private RelativeLayout bb;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Delar av filen activity_main.xml:
setContentView(R.layout.activity_main);
<RelativeLayout xmlns:android="http://sche..."
tf = (EditText) findViewById(R.id.editText1);
xmlns:tools="http://schemas.and..."
te = (EditText) findViewById(R.id.editText2);
android:layout_width="match_parent"
lbl = (TextView)findViewById(R.id.textView3);
android:layout_height="match_parent"
b3 = (Button)findViewById(R.id.button3);
tools:context=".MainActivity"
b4 = (Button)findViewById(R.id.button4);
android:id="@+id/layout" >
b3.setOnClickListener(this); //Som i ’vanlig’ Java
…
<Button
b4.setOnClickListener(this);
android:id="@+id/button1"
bb = (RelativeLayout)findViewById(R.id.layout);
android:layout_width="wrap_content"
} //Här skapas de olika objekten. bb är layotens
android:layout_height="wrap_content"
//bakgrund.
android:layout_alignLeft="@+id/editText2"
public void klickhanterare(View v) {
android:layout_below="@+id/editText2"
f = tf.getText().toString();
android:layout_marginTop="28dp"
e = te.getText().toString();
android:onClick="klickhanterare"
lbl.setText("Du heter " + f +" "+e);
android:text="@string/knapp1" />
} //Metoden som skriver ut texten. klickhaterare är en
…
<Button
//händelsehanterare i xml-filen kopplad till knapp1.
android:id="@+id/button2"
public void rott(View v) {
…
bb.setBackgroundColor(Color.RED);
android:onClick="rott"
} //Den röda bakgrundsfärgen är kopplad till knapp2
android:text="@string/knapp2" />
//på samma sätt via händelsehanteraren rott.
@Override
public void onClick(View view) { //Ett annan överskådligare händelsehantering är att lägga all
switch(view.getId()){
//kod i java-filen utan att använda händelsehanterare.
case R.id.button4:
//i xml-filen. Knapphändelserna hanteras av metoden onClick.
bb.setBackgroundColor(Color.WHITE); //Bakgrundsfärg
lbl.setTextSize(24);
//Textstorlek
lbl.setTextColor(Color.YELLOW);
//Textfärg
break;
case R.id.button3:
bb.setBackgroundColor(Color.GREEN);
break;
…
875099958
76
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Övning 0.18.5:
Följande exempel inneåller de tre form widgetskomponenterna TextView (label), Button och
TextFields. I övningen nedan skapas en app som
skriver ut texten som matas in i en textruta i en
label när en knapp klickas. Samtidigt skrivs även
texten ut i en Toast, d.v.s meddelanderuta. Du ska
nu göra app-projektet MataIn. Lös uppgiften
enligt handledningen på sidorna 15-22 i kapitel 18
i Java-javisst!. Förklaringarna av olika klasser
behöver inte läsas för att uppgiften ska kunna
lösas. Urklippet till höger visar hur den färdiga
appen ska se ut. När knappen klickas ska
dessutom texten bli gul och bakgrunden röd. Detta
görs med följande kod i metoden klickhanterare
i filen MainActivity.java:
lbl.setBackgroundColor(Color.RED);
lbl.setTextColor(Color.YELLOW);
Övning 0.18.6:
Gör app-projektet textapp med följande
funktioner:

Knappen Grön bak ger grön bakgrundsfärg
och skriver ”Grön bakgrund” i övre texten.

Knappen Röd bak, 25, gul ger röd
bakgrund, skriver Röd bakgrund i övre
texten, textstorlek 25 p och ger gul text.

Nästa knapp ger texten storlek 15 p med
blå text.

Knappen + text ökar övre textstorleken
med 1 p för varje klickning.

Knappen - text minskar övre textstorleken
med 1 p för varje klickning.

Försök att få komponenterna all ligga still
när textstorleken ändras och knapparna
klickas (se Beräkningar och layout nedan).
875099958
77
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Beräkningar och layout
Inläsningar från textrutor och beräkningar gör på liknande sätt som java. Inläsning från
textrutorna tf1 och tf2 till en hel- respektive decimaltalsvariabel görs med följande satser:
x = Double.parseDouble(tf1.getText().toString());
y = Integer.parseInt(tf2.getText().toString());
I xml-koden ska anges vilken typ av tal, hel- eller decimaltal, som textrutan hanterar:
android:inputType="numberSigned"
android:inputType="numberDecimal"
I förra uppgiften påverkades knapparnas lägen på appen av textstorleken på TextView. Detta
beror på att layouten är relativ (mer om RelativeLayout senare) och att komponenterna
automatiskt placeras i förhållande till
<Button
varandra när de skapas. Placeras en
android:id="@+id/button4"
komponent i förhållande till en
android:layout_width="wrap_content"
komponent vars storlek ändras kommer
android:layout_height="wrap_content"
den att förflyttas. Därför är det ju
android:layout_alignBaseline="@+id/button3"
lämpligt att komponenterna placeras i
android:layout_alignBottom="@+id/button3"
android:layout_alignRight="@+id/editText2"
förhållande till komponenter med
android:text="@string/div"
konstant storlek. I xml-koden till höger är
android:onClick="klickat" />
knappen högerjusterad i linje med
textrutan editText2:s högerkant.
Övning 0.18.7:
Gör app-projektet MataInTal enligt övningen på sidan 23 i kapitel 18 i Java-javisst!. Appen ska
dessutom ha följande funktioner.

I den övre inmatningsrutan ska det gå att mata in
decimaltal. Ändra till:
android:inputType="numberDecimal"
i filen activity_main.xml för textrutan, samt att
ändra till double i javafilen för inläsningen från
textrutan, samt på några variabler.

Koppla ytterligare två knappar för multiplikation
respektive division till händelsehanteraren klickat.

När appen körs rör sig troligen knappen multiplicera i
sidled när olika beräkningar görs. Justera layouten i
filen activity_main.xml så att Addera- och
Multipliceraknapparnas vänsterkant ligger i linje men
den andra textrutans vänsterkant och Subtrahera- och
Divisionsrutornas högerkant ligger i linje med den
andra textrutans högerkant genom att sätta:
android:layout_alignLeft="@+id/editText2"
android:layout_alignRight="@+id/editText2"
för de vänstra respektive högra knapparna.
875099958
78
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Radio- och bildknappar
När radioknapparna av klassen RadioButton skapas ligger det tre stycken i en gruppruta. Vill
man ha färre är det bara att radera en och vill man ha fler är det bara att lägga till en i xml-filen.
Endast en radioknapp i gruppen kan vara markerad åt gången. En radioknapp deklareras på
följande sätt i javafilen:
RadioButton Knapp0;
Kopplingen till knappobjektet i xml-filen görs med följande sats i javafilen:
Knapp0=(RadioButton) findViewById(R.id.radio0);
Följande sats är sann om radioknappen är markerad:
Knapp0.isChecked()
Övning 0.18.8:
Gör app-projektet Temperatur enligt övningen på sidan 27 i
kapitel 18 i Java-javisst!. Appen ska dessutom ha följande
funktioner.

Lägg till ytterligare två radioknappar för omvandling
mellan Celsius- och Kelvingrader.

Vid omvandlinf från Fahrenheit till Celsius blir det ofta
många decimaler. Alla temperaturer ska dock avrundas till
en decimal (se avsnitt 0.4 för avrundning).

När omvandlingen görs ska innehållet i textrutan markeras
så att innehåller raderas när ny temperatur matas in (se
avsnitt 0.4 för markering av innehåll i textruta).

Lägg i efterhand in en ikon för appen.
Övning 0.18.9:
Gör app-projektet Test enligt övningarna Hint och En knapp med
bild på sidan 30 i kapitel 18 i Java-javisst!. Appen ska dessutom
ha följande funktioner.

Lägg in två bildknappar (ImageButton).

Gör två bilder med storleken 70x50 pixlar för knapparna.
Beskär förslagsvis bilderna i Paint och ändra storleken. Lägg
in knapparna i bilderna.

Textrutan och knapparna ska ligga still oavsett hur TextViews
storlek ändras. Detta görs genom att ange deras läge till
appytans överkant till:
android:layout_marginTop="300dp" (textrutan)
android:layout_marginTop="400dp" (Knapparna)

När den vänstra knappen klickas skrivs den inmatade texten ut i TextView och ökar
storleken med 1 pixel. Den högra knappen skriver ut och minskar storleken med 1 pixel.
875099958
79
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Övning 0.18.10:
Gör spelet och app-projektet HiLo där användare ska försöka att gissa ett slumpat heltal mellan 1
och 100. Vid varje gissning anger programmet och det är för lågt, för högt eller om det är rätt
gissat. Programmet (appen) ska ha följande funktionalitet:

Appen innehåller två TextView, två knappar och en textruta för
inmatning av endast heltal, som formateras med följand sats i
xml-filen: android:inputType="numberSigned"

När programmet startas slumpas automatiskt ett nytt tal, den
andra TextViewn anger ”Antal gissningar=0”, knappen Nytt
spel går ej att klicka (sätt b2.setEnabled(false);), hinttexten i
editrutan är Heltal mellan 1 och 100, bakgrundsfärgen är grön,
samt textrutan är fokuserad.

När knappen Mata in klickas markeras det inmatade talet, antal
gissningar skrivs ut, samt om det är för lågt, högt eller rätt.
Markering av texten görs med följande satser:
tf.requestFocus();
tf.selectAll();
//Fokuserar textrutan tf
//Markerar innehållet

Matas rätt tal in blir knappen Mata in ej klickbar, knappen Nytt
spel klickbar, samt bakgrundsfärgen röd.

När knappen Nytt spel klickas slumpas ett nytt tal att gissa på,
knappen blir ej klickbar, knappen mata in blir klickbar,
bakgrunden blir grön och proceduren från punkt två ovan
upprepas.
Layouter
Hittills har vi använt RelativeLayout, vilket är det layoutalternativ som erhålls om inga val görs.
Komponenterrna placeras här relativt varandra efter hand som de skapas. Nackdelen med detta,
som vi sett i några av exemplen ovan, är att komponenter som skapats senare kan ändrar sina
placeringar om en storleken hos en komponent som skapats tidigare ändras. Placeringen kan
dock ändras via xml-filen. Följande layouter finns tillgängliga:

RelativeLayoute – komponenter placeras i förhållande till varandra (se ovan).

LinearLayout – komponenterna placeras efter varandra, antingen horisontellt eller vertikalt
beroende på vilket man väljer. De kan även höger- eller vänster vänsterjusteras eller
centreras.

TableLayout – komponenterna placeras i rader och kolumner (se övning nedan).

FrameLayout – komponenterna hamnar längst upp i vänstra hörnet. Layouten används
främst för grafik.
875099958
80
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Övning 0.18.11:
Gör app-projektet KeyPad enligt övningen på sidan 32 i
kapitel 18 i Java-javisst!. Appen ska dessutom ha följande
funktioner.
 Lägg även in knappar för +, -, = och C (radera).
 Gör så att ett tal matas in i textrutan när knapparna
klickas. Använd metoderna från gränssnitter
OnClickListener. Inläsningen från en knapp till
textrutan görs förslagsvis med följande kod för i
metoden onClick(View view):
switch (view.getId()) {
case R.id.button1:
str = str + "1";
tf.setText(str);
break;

Räknesätten fungerar lite bakvänt:
case R.id.button11:
if (str=="")
str="0";
sum=sum+Integer.parseInt(str.toString());
str="";
tf.setText(str);
break;
o Första talet matas in.
o Sedan anges talets tecken (+/-).
o Andra talet matas in.
o Räknesättet anges
case R.id.button13:
tf.setText(""+sum);
break;
o Knappen för = ger resultatet.
o Vill man fortsätta att räkna matas ett nytt tal
in.
break;
o Ange räknesätt. Koden till höger visar knappen (11) för addition. Koden för ”=”
visas ovan för knappen 13.
o Knappen för ”=” ger resultatet, o.s.v. Detta sättet att räkna kallas omvänd polsk
notation och användes av de äldre HP-räknare (1980-talet).

Gör så att knappen C
raderar textruta och
’minne’. Koden för Cknappen (14) visas till
höger.
875099958
case R.id.button14:
sum=0;
str="";
tf.setText("");
break;
81
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Grafik
I Android användsgrafikrutiner på ett liknande sätt som i Java. Layouten FrameLayout används
för grafiken, som hanteras i en egen javaklass, som i sin tur anropas och körs av den vanliga
javaklassen MainActivity. Hur dessa kopplingar görs beskrivs med början på sidan 35 i kapitel
18 i Java-javisst!.
Övning 0.18.12:
Påbörja app-projektet Figurer med FrameLayout, enligt
övningen på sidan 34 i kapitel 18 i Java-javisst!, utan att
lägga in någon TextView. Fortsätt sedan med övingen
Rita grafik på sidan 35 och lös den så att appen får
samma utseende som urklippet till höger. Observera att
alla objekt skapas i konstruktorn MinView(Context cxt) i
klassen MinView.java, medan grafiken utförs i klassens
metod onDraw(Canvas cvs). Appen körs med klassen
MainActivity.java. Lös uppgiften på följande sätt:

Gul bakgrund fås med följande kod i konstruktorn
MinView:
cvs.drawColor(Color.YELLOW);

Skapa Paint-objektet stil med följande koder i
konstruktorn MinView:
stil = new Paint(Paint.ANTI_ALIAS_FLAG);
stil.setColor(Color.RED);
stil.setTextSize(30);

Skapa fontobjektet typ av klassen Typeface för kursiv stil med seriffer (fötter) med följande
kod:
typ = Typeface.create(Typeface.SERIF, Typeface.ITALIC);
stil.setTypeface(typ);

Skriv in texten Några olika canvasfigurer överst på sidan med koden i metoden onDraw:
cvs.drawText("Några olika canvasfigurer", 0,30,stil);

Lägg in en fylld cirkel med centrum i (150, 100) och radien 100 och texten med följande
kod i metoden onDraw:
cvs.drawCircle(150, 200, 100, stil);
cvs.drawText("Fylld cirkel",150,200,stil2);

Skapa Paint-objektet stil2 med följande kod i konstruktorn MinView:
typ2 = Typeface.create(Typeface.SANS_SERIF, Typeface.NORMAL);
stil2 = new Paint(Paint.ANTI_ALIAS_FLAG);
stil2.setColor(Color.BLUE);
stil2.setStyle(Paint.Style.STROKE); //Stroke ger ej fylld figur
stil2.setTypeface(typ2);

Lägg in en ofylld rektangel och text med koden i metoden onDraw:
cvs.drawRect(150,350,250,450,stil2);
cvs.drawText("Ofylld rektangel (stroke)",100,400,stil2);
875099958
82
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA

av Anders Andersson
Lägg in en fylld röd rektangel och text med koden i metoden onDraw:
cvs.drawRect(150,500,450,600,stil);
cvs.drawText("Fylld rektangel", 150,550,stil2);

Spara en egen bild i mappen Figurer/res/drawable-ldpi. Om bilden har filnamnet bb.jpg
läggs den in med följande kod i metoden MinView:
Bitmap minBild; //Skapa bildobjektet minBild av klassen Bitmap utanför MinView
minBild = BitmapFactory.decodeResource(getResources(),R.drawable.bb);

Följande kod för bilden läggs i metoden onDraw:
minBild = Bitmap.createScaledBitmap(minBild,200,400,false); //Bildmått 200x400
cvs.drawBitmap(minBild, 260, 70, null); //Bildens övre högra hörn i (260,70)
cvs.drawText("Bild", 300,60,stil2); //Texten Bild läggs in i (300,60)
Övning 0.18.13:
Kopiera förra app-projektet Figurer i Eclipse och klistra
in en kopia som och döps till Figurer2. Modifiera sedan
appen så att den får utseendet som utklippet till höger. Lös
uppgiften på följande sätt:

Rita ut 1000 fyllda cirklar med diametern 25 pixlar
med slumpmässig placering och slumpmässiga färger.
Cirklarna ska ligga 25 pixlar från högerkanten.
Använd följande metoder på lämpligt sätt:
(int)(Math.floor(Math.random()*256)) //Slumptal
stil.setColor(Color.rgb(r,g,b); //Ger rgb-färg
cvs.getWidth(); //Ger skärmens pixelbredd
cvs.getHeight(); //ger skärmens pixelhöjd

Rita en cirkel med fyllning enligt klassen
RadialGradient, enligt den översta cirkeln i
urklippet. Cirkeln har radien 100 pixlar. Använd exakt
följande metoder:
RadialGradient radGrad = new
RadialGradient(250, 100, 100, Color.GREEN,
Color.RED,Shader.TileMode.MIRROR);
stil.setShader(radGrad);
cvs.drawCircle(250,100,100,stil);

Rita en cirkel med fyllning enligt klassen SweepGradient, enligt den ’koniska’ cirkeln i
mitten i urklippet. Använd exakt följande metoder:
SweepGradient swepgrad= new SweepGradient(250,300, new int[]
{Color.RED,Color.YELLOW,Color.GREEN,Color.BLUE,Color.MAGENTA},null);
stil.setShader(swepgrad);
cvs.drawCircle(250,300,100,stil);

Rita en cirkel med fyllning enligt klassen LinearGradient, enligt den ’randiga’ cirkeln
nederst i urklippet. Använd exakt följande metoder:
LinearGradient linGrad = new
LinearGradient(0,0,25,25,Color.RED,Color.BLACK,Shader.TileMode.MIRROR);
stil.setShader(linGrad);
cvs.drawCircle(250,500,100,stil);

Observera att de tre större cirklarna tangerar varandra.
875099958
83
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Animering
I detta exemplet visas animering av grafiska objekt och touchhändelser på skärmen. I den färdiga appen rör sig en röd cirkel
på en grön bakgrund samtidigt som cirkelns koordinater visas i
övre vänstra hörnet, enligt urklippet. Även läget hos en blå
rektangel påverkas av var på skärmen man trycker.
Övning 0.18.14:
Skapa projektet Pong och följ sedan exemplet på sidan 38 i
kapitel 18 i Java-javisst!. Den färdiga koden för de tre javafilerna
finns länkad nedan.

Klassen boll.java beskriver den röda cirkeln och dess läge på
skärmen.

Här är klassen MainActivity.java. Gränssnitten Runnable
och OnTouchListener innehåller metoden run för animering (trådar) respektive
touchmetoden onTouch för skärmen. Klassen Handler hanterar tråden.

Klassen Racket.java beskriver den ljusblå racketen och dess läge på skärmen.

*Gör klart Pong-spelet.
Bilderväxlingar ImageViews
Komponenten ImageViews är en behållara för bilder. I följande
övning skapar vi en app som låter oss byta mellan fyra bilder på
några olika sätt med sex knapper, enligt urklippet med gojorna
till höger, samt tonar bildbyten.
Övning 0.18.15:
Skapa projektet ImageTest och följ sedan exemplet på sidan 43
i kapitel 18 i Java-javisst! t.o.m. knappen OFF. Fortsätt sedan
med att lägga in övriga knappar:

Hämta de två bilderna goja.jpg och pingvin.jpg från
JavaJavisst och lägg dem i mappen drawable-ldpi. Hämta
ytterligare två egna bilder och beskär dem till 200x200 i
Paint innan de läggs i mappen ovan.

Byt bilder kopplas till egna metoden klicka. Varje klick på
knappen byter bild. Efter fyra klick visas första bilden igen.

De nedersta fyra knapparns kopplas alla till den egna metoden klick4. Klickas på en knapp
visas respektive bild. De ligger dessutom i en linjär layout.

Bildspel startar en tråd som slumpar en ny ny bild varje sekund.

Byt bilder tonar fram bilderna. Här är appens MainActivity.java.
875099958
84
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Menyer
Ska våra appar bli användbara bör de byggas upp med menyer.
Följande exempel består av en startsida i form av en huvudmeny
med två knappar, rubricerad Menysidan, varifrån två val kan göras
för addition respektive subtraktion.
package com.example.menyer;
Klickas knapparna öppnas två sidor
import android.app.Activity;
rubricerade Addera respektive Minus.
import android.content.Intent;
import android.os.Bundle;
Dessa båda sidor innehåller knappen
import android.view.Menu;
Tillbaka, som öppnar huvudmenyn. Appen
import android.view.View;
är skapad på följande sätt:
public class MainActivity extends Activity {
Menysidan
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
1) Skapa först projektet Menyer. Då
skapas samtidigt det som ska bli
startsidans javaklass
MainActivity.java och layoutfil
activity_main.xml.
public void addera(View v) {
Intent myIntent = new Intent(this, AdderaKlass.class);
startActivity(myIntent);
}
2) xml-filens innehåll raderas och den
ges en linjär vertikal layout med
centrerad text och två knappar.
public void minus(View v) {
Intent myIntent = new Intent(this, MinusKlass.class);
startActivity(myIntent);
}
3) onClick-metoderna addera och minus
skapas för respektive knapp i xmlfilen.
@Override
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.activity_main, menu);
return true;
}
}
4) Lägg in metoderna addera respektive
minus i klassfilen för att öppna de andra menyerna med
klasserna AdderaKlass.class och MinusKlass.class, som
skapas nedan.
Adderasidan
5) Nu skapar vi xml-filen
activity_addera.xml i mappen
res/layout för menyvalet Addera.
Kopiera föslagsvis in xml-koden från
startsidan och ändra text och färg.
package com.example.menyer;
import android.os.Bundle;
import android.app.Activity;
import android.content.Intent;
import android.view.Menu;
import android.view.View;
public class AdderaKlass extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_addera);
}
6) onClick-metoderna tillbaka skapas för
knappen Tillbaka i xml-filen.
7) Skapa klassfilen AdderaKlass.java i
mappen src/com.exemple.menyer
som hanterar koden för Adderasidan.
Klassfilen måste deklareras i filen
AndroidManifest.xml via valen
Application/Add/Activity, samt
därefter välja filen AdderaKlass.java
vid Name till höger.
875099958
public void tillbaka(View v) {
Intent myIntent = new Intent(this, MainActivity.class);
startActivity(myIntent);
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.activity_main, menu);
return true;
}
}
85
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
8) Lägg in metoden tillbaka i klassfilen som öppnar
startsidan.
Minussidan
9) Skapa filerna activity_minus.xml
och MinusKlass.java på
motsvarande sätt som för
Adderasidan, vars kod förslagsvis
kopieras och ändras på lämpligt sätt,
enligt urklippet till höger.
package com.example.menyer;
import android.os.Bundle;
import android.app.Activity;
import android.content.Intent;
import android.view.Menu;
import android.view.View;
public class MinusKlass extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_minus);
}
Ändra startsida
Vilken sida (klassfil) som ska vara
startsida anges i filen
AndriodManifest.xml i activity-delen. I
början anges startsidans klassfil och
längre ner klassfilerna som tillhör
projektet, enligt urklippet nedan. Är den
första java-filen som skapas startsidan
behöver man inte tänka på detta.
public void tillbaka(View v) {
Intent myIntent = new Intent(this, MainActivity.class);
startActivity(myIntent);
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.activity_main, menu);
return true;
}
}
Del av filen AndroidManifest.xml
…
<activity
android:name="com.example.menyer.MainActivity"
android:label="@string/app_name" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<activity android:name="AdderaKlass"></activity>
<activity android:name="MinusKlass"></activity>
…
875099958
86
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
Ljud
av Anders Andersson
package com.example.ljud;
Vi ska nu se ett ett exmpel på hur
ljudfiler (.mp3) anropas. Skapa först
app-projektet ljud. Skapa sedan
foldern raw i mappen …res/raw
där ljudfilen placeras. I detta
exempel heter filen kali.mp3. xmlfilen innehåller de två knapparna
Start 1 och Stopp 1, enligt urklippet,
som startar och pausar mp3-filen.
Knapparna är kopplade till onClickmetoden starta(View v), i
kodexemplet till höger. Provkör
ljudexemplet.
Gruppuppgift – turistapp
import android.app.Activity;
import android.media.MediaPlayer;
import android.os.Bundle;
import android.view.Menu;
import android.view.View;
public class MainActivity extends Activity {
MediaPlayer Song;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Song=MediaPlayer.create(MainActivity.this,R.raw.kali);
}
public void starta(View v) {
switch (v.getId()) {
case R.id.button1:
Song.start();
break;
case R.id.button2:
Song.pause();
break;
}
}
Android är ett väldigt stort
operativsystem med många
möjligheter, av vilka vi nu lärt oss
@Override
en liten del. Dock tillräckligt många
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.activity_main, menu);
för att vi ska kunna göra en
return true;
funktionell turistapp för
}
}
Kristinehamn, vilken med text, ljud
och bild berättar om kommunens
historia och sevärdheter. Appen kan ha följande menyer:

Startmenyn (meny 1) – här väljs språken svenska, engelska eller tyska via knappar mot
en bakgrundsbild av Kristinehamn.

När ett språk valts visas en ny meny (meny 2) med text (TextView) och små bilder
(ImageButton) för alla sevärdheter i en vertikal LinearLayout.

Klickas en bildknapp kommer man till en meny (meny 3) för just den sevärdheten, som
innehåller ett bildspel med några bilder, en knapp som öppnar en ny meny (meny 4)
som med text berättar om sevärdheten, samt en knapp som startar en mp3-fil som med
en röst berättar det som texten beskriver. Ljudinspelningen görs förslagsvis med datorns
Ljudinspelaren till en wma-fil, som sedan konverteras till mp3-format.

Varje meny innehåller en knapp som backar till föregående meny.
Meny 1 finns endast i en version, medan menyerna 2-4 finns för varje språk. Börja förslagsvis
med att göra i ordning menystrukturen med de fyra menynivåerna för den svenska versionen på
en dator under projektnamnet Kristinehamnsapp. Kopiera sedan projektet till
gruppmedlemmarnas alla datorer och utvecka menyerna 3 och 4. När den svenska versionen är
klar kan den kopieras och ändras till övriga språk. För att appens funktionalitet ska framgå
föreslår jag att ni inledningsvis fokuserar på fem sevärdheter som redovisas på alla tre språken.
Kristinehamns sevärdheter beskrivs under http://www.kristinehamn.se/turism-kulturfritid/sevardheter Välj förslagsvis Picassoskulpturen, Ölme Diversehandel, Familjen Fröding,
Kristinehamns kyrka, samt runstenen i Järsberg. När dessa fungerar kan ni utöka med fler. När
de fem sevärdheterna är klara överför vi appen till mitt konto på Google play.
875099958
87
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Publicera appar på Google Play
Nu är det dags att publicera den färdiga andriodappen på Google play, vilket görs i två steg:
1. Först skapas en apk-fil (som är en slags komprimering av alla filer som ingår i projektet)
av app-projektet. Filmen http://thenewboston.org/watch.php?cat=6&number=199 visar
hur det görs i Eclipse. Det är viktigt att package namnet inte börjar på com.example…,
som våra appar hittills gjort, för då fungerar inte överföringen till Goggle play senare.
apk-filen i bin-mappen kan inte överföras direkt, utan följannde steg måste göras:
a. Högerklicka på app-projektet (t.ex. ljud) och välj Export/Android/Export
Android Application.
b. Välj projekt att exportera.
c. Skapa en keystore om det inte gjorts tidigare (t.ex. anderskeystore). Skapa även
en mapp där för keystore (t.ex. Androidappar) där apk-filerna och keystore
sparas.
d. Hitta på ett lösenord.
e. Skapa ett alias (anders).
f. Spara apk-filen
(t.ex. ljud.apk).
g. Avsluta
2. Överföringen av apk-filen
till Google Play görs på
sidan Google Play
Developer Console
https://play.google.com/apps/publish. Här görs också registreringen till en kostnad av 25
dollar (betala via kontokort) för att kunna distribuera appar till användare av Androidmobiler via Google play. Filmen ovan vid punkt 1) visar hur överföringen görs i den
äldre versionen Android Market, men det påminner om det nyare Google play. När
betalningen är gjord är man registrerad och kan överföra sina apk-filer (exempelvis
mappen androidmappar), beskriva sin app i text, samt överföra åtminstone två
skärmdumpar av appen i angivna upplösningar. Sen tar det några timmar innan appen
syns på Google play. I Developer Console syns även inlagda appar, enligt bilden ovan.
Kolla om ni hittar min app HiLo Spelet (sök eventuellt på Brogårdsgymnasiet
Kristinehamn Sweden eller [email protected]). Att lägga ut appar är
lite mer tids- och arbetskrävande jämfört med att överföra html-filer i en webbserver.
875099958
88
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
1. Vi börjar programmera
Inledning
Denna kurs i Java-programmering bygger på goda kunskaper i språket C++ och på att begrepp
som variabler, urval, loopar, objekt etc. är kända. Kan man C++ är det dock relativt enkelt att
lärar sig Java, eftersom Java till härstammar ifrån och till stor del har samma syntax som C++.
Språket Java skapades 1991 av den kanadensisk-amerikanske programmeraren James Gosling
vid dataföretaget Sun Microsystem och blev allmänt tillgängligt 1995. Ursprungligen var Java
tänkt som ett språk för konsumentartiklar (typ tvättmaskiner), men kom i början främst att
användas för bla grafiska effekter med s k applets på Internet. Java har emellertid nu slagit
igenom stort och i viss mån ersatt traditionella språk som C++. Java har många fördelar:

Syntaxen är i stort sett identisk med C++. Java är därför relativt enkelt att lära sig för den
som redan kan C eller C++.

Det är plattformsoberoende, d v s ett program kan köras i olika operativsystem (Windows
2000, Unix etc.) utan att ändras.

Det innehåller grafiska verktyg såsom knappar och textrutor (som VB) även om
programmeringen görs i en texteditor.

Det stödjer s k trådar (threads). Exempelvis kan det rita upp en bild samtidigt som det
gör en inläsning.

Det kan användas på Internet för att skapa dynamiska funktioner på webbsidor. Detta
görs med javaapplets.

Det saknar pekare, vilket innebär att ett program i Java ofta är enklare att förstå än i C++.
Java har också några nackdelar:

Det är ett s k interpreterande (d v s översätter kod vid varje exekvering) språk och därför
långsammare än t ex C++. Detta kompenseras dock av att dagens datorer är så pass
snabba att detta ofta inte är något hinder.

Det är ett innehållsrikt språk med väldigt många färdiga standardklasser (bl a för grafik)
som kan vara svåra att få grepp om. Man behöver dock inte lära sig allt på en gång.
I denna javakurs berörs främst syntax och begrepp som skiljer sig från C++, som tas upp i
kursdokumentet http://hem.passagen.se/anderskristerandersson/data/Cplus_lektioner.doc.
Nedladdning och installation av Java
En av fördelarna med Java är att utvecklingsmiljön JDK (Java Development Kit, som bl a
innehåller kompilatorn) är gratis. Programmet (52 MB) j2sdk-1_4_2_07-windows-i586-p.exe
laddas ner från företaget Suns hemsida http://java.sun.com/j2se/1.4.2/download.html till din
dator. När programmet installeras skapas mappen c:/ j2sdk1.4.2_07, där programmet packas
upp. Javaprogrammen utvecklade med JDK och körs sedan i konsollmiljö, d v s programmen
skrivs i en textredigerare typ Anteckningar och de kompileras och exekveras i MS-DOS via
Kommandotolken i Tillbehör. I mappen c:/ j2sdk1.4.2_07/bin finns bl a filen javac.exe, som
används för att kompilera javaprogram. Väljer vi att spara våra javaprogram i en annan mapp än
875099958
89
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
mappen bin ovan, vilket är det vanligaste, måste
sökvägen anges till bin-mappen så att filen
javac.exe hittas. Detta är krångligt. För att slippa
ange sökvägen kan vi istället lägga in en sökväg
(path) till mappen bin via
Kontrollpanelen/System/Avancerat/Miljövaria
bler. Markera Path i den undre rutan och klicka
på knappen Redigera. Skriv där in sökvägen C:\j2sdk1.4.2_07\bin, enligt urklippet intill.
Javaprogram kan nu kompileras och köras (exekveras) via kommandotolken.
Java med TextPad
För att slippa skriva javaprogrammen i Anteckningar och kompilera och exekvera i DOS-miljön
skall vi använda oss av editeringsprogrammet TextPad. Programmet (2Mb) laddas ner från
http://www.download.com. Installera programmet och öppna det sedan via Start/Alla program.
Programmet TextPad är en mer avancerad editor än Anteckningar, bl a görs automatisk
indentering och färgning av texten. Dessutom kan javaprogrammen kompileras och köras i
TextPad, utan att sökvägen till bin-mappen i Miljövariabel behöver anges (som i förra stycket).
Programmet kompileras och körs via menyvalet Tools/Compile Java (Ctrl+1) respektive
Tools/Run Java Application (Ctrl+2).
Javadokumentation
Java är ett stort språk med väldigt många standardklasser och metoder. Detta finns samlat i en
dokumentation som kan laddas ner som ett zippat dokument (30 MB) från Suns hemsida
http://java.sun.com/j2se/1.4.2/download.html. Uppackat blir dokumen knappt 200 MB stort.
Dokumentet finns även uppackat i j:/Anders_A/java/javadokumentation/index.html.
875099958
90
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Första programmet i Java - utmatning
Skriv in följande program i TextPad:
class test1{
public static void main(String args[]){
System.out.println("Det funkar i textpad!");
System.out.println("Deta är andra raden");
System.out.print("Tredje raden");
System.out.print("Fjärde raden");
}
}
//Klamrar på samma rad (ej som i C++)
//main-metoden börjar
//Ger utskrift
//println, ny rad efter utskrift
//print, ej ny rad efter utskrift
//main-metoden slutar
Programmets enda klass heter test1, som kan ses som programmets namn. Källkodfilen skall ha
samma namn som programmet. Spara därför programmet som test1.java i mappen java, där du i
fortsättningen sparar alla dina javaprogram. Filslutet .java anger att det är en källkodfil för ett
javaprogram. Kompilera nu programmet till bytekod (andra program kompilerar direkt till
maskinkod). Då skapas klassfilen test1.class, som är plattformsoberoende. När klassfilen sedan
körs med en javatolk interpreteras den till maskinkod. Ordet public anger att main-metoden
(som i C++) är åtkomlig utifrån klassen (programmet) test1, vilket den måste vara för att den
skall kunna anropas av av interpretatorn. Ordet static anger att main-metoden är en s k
klassmetod (eller statisk metod), d v s en metod som inte hör till ett visst objekt. Parametern
String args[] i main-metoden skall alltid vara med för att main-metoden skall kunna anropas
med en parameter, vilket dock sällan görs. Följande program illustrerar variabeldeklaration och
addition. Observera likheterna med C++:
class test3{
public static void main(String args[]){
int a,b=5;
double c=3.33;
a=7;
System.out.println("Summan är " + (a+b) +" och decimaltalet " + c);
}
}
Utelämnas parentesen runt additionen (a+b) i utskriften blir värdet 75.
875099958
91
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Inmatning med standardklasser
Som du såg i förra exemplen är utskrift i textfönstret i Java relativt enkelt. Inläsning från
tangentbordet är krångligare. Främsta skälet till detta är att Java oftast använder grafiska
gränssnitt och därför saknar bra standardklasser för konsollprogrammering.
String och tecken
Följande program läser in och skriver ut två textsträngar:
import java.io.*; //Standardpaketet java.io.* innehåller metoder för in- och utmatning.
class test3{
public static void main(String args[]) throws IOException{
//Tar hand om fel i readLine()
String fnamn, enamn;
//Klassen String används (jämför med C++)
BufferedReader in=new BufferedReader(new InputStreamReader(System.in));//krångligt
System.out.print("Ange ett förnamn: ");
fnamn=in.readLine();
//Förnamnet läses in
System.out.print("Ange ett efternamn: ");
enamn=in.readLine();
//Efternamnet läses in
System.out.println("Du matade in namnet " + fnamn + " " + enamn);
}
}
Vad den krångliga raden som skapar (objekt-) strömmen in för inläsning egentligen innebär bryr
vi oss inte om. Enskilda tecken (char) plockas enklast ur en inläst string:
System.out.print("Ange en tecken: ");
String s=in.readLine();
System.out.println("Du matade in tecknet " + s.charAt(0));
//Ger strängens första tecken
String-metoden s.charAt(n) plockar ut n:te tecknet ur strängen s. Följande metoder finns för
hantering av strängar, d v s metoder i klassen String:
str.length()
str.charAt(n)
str.substring(n)
str.substring(n,m)
str.compareTo(str2)
str.equals(str2)
str.equalsIgnoreCase(str2)
str.startsWith(str2)
str.startsWith(str2,n)
str.endsWith(str2)
str.indexOf(c)
str.indexOf(c,n)
str.lastIndexOf(c)
str.lastIndexOf(c,n)
str.indexOf(str2)
str.indexOf(str2,n)
str.lastIndexOf(str2)
str.lastIndexOf(str2,n)
str.trim()
str.replace(c1,c2)
str.toUpperCase()
str.toLowerCase()
String.valueOf(x)
875099958
//ger antalet tecken i str
//ger tecknet i position n
//ger den delsträng som börjar i position n
//ger den delsträng som börjar i position n och slutar i m-1
//ger 0 om str = str2 , <0 om str kommer före str2 annars >0
//true om str och str2 är lika, annars false
//samma som ovan, men skiljer inte på stora och små bokstäver
//true om str inleds med strängen str2, annars false
//true om strängen str2 börjar i position n i str, annars false
//true om str avslutas med strängen str2, annars false
//ger första positionen om tecknet c finns i strängen str, annars -1
//letar från position n efter första platsen för tecknet c
//ger sista positionen om tecknet c finns i strängen str
//letar från position n efter sista platsen för tecknet c
//ger första positionen för delsträngen str2 i str
//letar från position n efter första platsen för strängen str2
//ger sista positionen om delsträngen str2 finns i strängen str
//letar från position n efter sista platsen för delsträngen str2
//returnerar str utan inledande och avslutande blanktecken
//ersätter alla tecken c1 med tecken c2 (å, ä och ö går ej att ersätta)
//ändrar till enbart stora bokstäver
//ändrar till enbart små bokstäver
//omvandlar x till en sträng (x är enkel taltyp: int , double osv)
92
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Heltal och decimaltal
All inläsning görs som strängar och omvandlas sedan till t ex integer eller double. Följande
program läser in och skriver ut hel- och decimaltal:
import java.io.*;
class test3{
public static void main(String args[]) throws IOException{
int i;
double d;
String s;
BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
System.out.print("Ange ett heltal: ");
s=in.readLine();
i=Integer.parseInt(s);
//Omvandlar sträng till heltal
System.out.println("Du matade in heltalet " + i);
System.out.print("Ange ett decimaltal: ");
s=in.readLine();
d=Double.parseDouble(s);
//Omvandlar sträng till decimaltal
System.out.println("Du matade in decimaltalet " + d);
}
}
Metoderna parseInt(s) och parseDouble(s) tillhör klasserna Integer respektive Double. Inläsning
till heltal direkt kan göras med följande sats:
int antal=Integer.parseInt(in.readLine());
Avrundning
Även avrundning är ganska krånkligt i Java. Följande program avrundar till tre decimaler:
import java.io.*;
import java.text.*;
//Klassen NumberFormat finns i detta paket
class test3{
public static void main(String args[]) throws IOException{
double d=3.823456;
NumberFormat r = NumberFormat.getInstance();
//Instans av redigerare r
r.setMaximumFractionDigits(4);
//Formaterar utrskrift till högst 4 decimaler
System.out.println("Med fyra decimaler: " + r.format(d) );
//Omvandlar decimaltalet d till
//en sträng med 4 decimaler
}
}
Heltalsdivision
Fungerar på samma sätt som i C++, d v s är båda termerna heltal blir kvoten ett heltal. Problemet
löses med casting, d v s omtypning.
ASCII-kod
ASCII-koden erhålls i Java liksom i C++ genom omtypning av ett tecken:
String s="Anders";
System.out.println("ASCII-koden för femte tecknet: " + (int)s.charAt(4));
Tecknet för motsvarande ASCII-kod fås på omvänt sätt:
int i=232;
System.out.println("Tecknet är: " + (char)i);
875099958
93
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Matematiska funktioner
Klassen Math i Java har några metoder (funktioner) som C++ saknar. Följande program visar
vilka:
import java.io.*;
import java.lang.*;
//Innehåller klassen Math. Paketet behöver inte importeras, finns alltid med.
class test3{
public static void main(String args[]) throws IOException{
System.out.println(Math.PI);
//Ger pi med 15 decimaler
System.out.println(Math.pow(5,2));
//25.0
System.out.println(Math.sqrt(49));
//7.0
System.out.println(Math.random());
//Slumptal mellan 0-1. ’Blandas’ automatiskt.
System.out.println(Math.max(5,8));
//8
System.out.println(Math.min(5,8));
//5
System.out.println(Math.round(5.5)); //6
}
}
Observera att klassnamnet Math måste föregå metodanropet. Nedan följer en sammanställning
av de matematiska metoderna:
Math.abs(a)
Math.max(a,b)
Math.min(a,b)
Math.PI
Math.E
Math.exp(x)
Math.log(x)
Math.sqrt(x)
Math.ceil(x)
Math.floor(x)
Math.pow(x,y)
Math.round(x)
Math.random()
Math.sin(x)
Math.cos(x)
Math.tan(x)
Math.asin(x)
Math.acos(x)
Math.atan(x)
//absolutvärdet eller beloppet av talet a
//ger det största av talen a och b
//ger det minsta av talen a och b
//talet 
//talet e = 2,7…
//ger ex
//ger naturliga logaritmen av x
//ger kvadratroten av x
//rundar av uppåt till heltal
//rundar av nedåt till heltal
//ger xy
//avrundar till heltal av typ long
//ger slumptal mellan 0 och 1
//x anges i enheten radianer
//arcsin(x), motsvarar miniräknarens sin-1. Returnerar ett värde i radianer.
Urval och loopar
Urval med if och case, samt looparna for och while har samma syntax i Java som i C++.
875099958
94
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Fält (array)
Ett fält (vektor, array) kan initieras på två sätt i Java:
0
1
2
3
100
200
255
187
int[] x={100, 200, 255, 187};
Eller så här:
X:
int[] x=new int[4];
x[0]=100;
x[1]=200;
x[2]=285;
x[3]=187;
Följande sats innebär att x och y refererar till samma fält:
y=x;
Vill man istället kopiera innehållet i fältet x till ett nytt fält y görs detta med standardmetoden
clone:
y=(int[]) x.clone();
I Java är fält dynamiska så till vida att storleken kan anges vid exekveringen (jämför med pekare
i C++). Dessutom innehållet klassen Arrays metoder för bl a sortering, sökning och jämförelse
av fält. Följande program illustrerar hur en vektor fylls med hela slumptal mellan , sorteras i
stigande ordning, samt slutligen skrivs ut igen:
import java.io.*;
import java.lang.Math;
import java.util.Arrays; //Importerar klassen Arrays för att kunna sortera fältet nedan
class test3{
public static void main(String args[]) throws IOException{
int [] a=new int[10];
//Deklarerar fältet med new (påminner om pekare i C++)
for (int i=0;i<10;i++)
a[i]=(int)(Math.random()*5)+1; //Fyller fältet med slumptal mellan 1 och 5
Arrays.sort(a);
//Sorterar fältet i stigande ordning
for (int i=0;i<10;i++)
System.out.println(a[i]);
}
}
Sortering av strängar görs på liknande sätt. Sorteringen fungerar dock endast om hela det
deklarerade fältet är fyllt. Deklarationen av fältet görs därför efter inläsningen av fältets storlek:
System.out.print("Ange hur många namn som skall matas in: ");
int antal=Integer.parseInt(in.readLine());
//Omvandling till heltal görs direkt
String [] a=new String[antal];
Klassen Arrays innehåller bl a följande användbara metoder:
a.length
Arrays.equals(a,b)
Arrays.fill(a,b)
Arrays.fill(a,m,n,b)
Arrays.sort(a)
Arrays.sort(a,m,n)
binarySearch(a,b)
//Ger antalet komponenter i a (tillhör ej klassen Arrays)
//Returnerar true om fälten a och b är lika (komponenter och antal)
//Ger alla komponenterna i fältet a värdet b
//Returnerar komponenterna nr m till n-1 I fältet a värdet b
//Sorterar komponenterna i a i stigande ordning
//Sorterar komponenterna nr m till n-1 i a i stigande ordning
//Söker efter variabeln b i fältet a. Returnerar b:s index om den finns, annars -1
Övning 1.1:
Skriv ett program som skriver ut följande textsträng på skärmen:
Detta är kul. Detta är kul. Detta är kul.
875099958
95
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Övning 1.2:
Skriv ett program som läser in ett namn och sedan skriver ut det på skärmen på tre rader:
Vad heter du: Anders Andersson
Var bor du? Skoghall
Du heter Anders Andersson och bor i Skoghall
Du heter Anders Andersson och bor i Skoghall
Du heter Anders Andersson och bor i Skoghall
Övning 1.3:
Skriv ett program som beräknar resten vid division mellan två heltal. Programmet skall ha
följande utskrift:
Ange taljare: 16
Ange namnare: 6
Rest vid division: 4
Heltalsdivision: 2
Kvot med alla decimaler: 2.6666666666666665
Kvot med tre decimaler: 2.667
Övning1.4:
Skriv ett program som läser in en textrad och antal gånger som den skall skrivas ut och som
sedan skriver ut texten, med följande utskrift:
Ange en text: Jag gillar Java
Antal gånget texten skall skrivas ut: 4
1: Jag gillar Java
2: Jag gillar Java
3: Jag gillar Java
4: Jag gillar Java
Övning 1.5:
Skriv ett program som läser in en sträng och som sedan skriver ut antal tecken, texten med
versaler, ersätter alla mellanslag (’ ’) med bokstaven ’a’, samt skriver ut texten baklänges, enligt
följande exempel:
Ange en text: Jag gillar Java
Antal tecken: 15
JAG GILLAR JAVA
JagagillaraJava
avaJ rallig gaJ
Övning 1.6:
Skriv ett program som läser in två namn och som sedan skriver ut dem i bokstavsordning med en
if-sats, med följande utskrifter:
Ange första namnet: kalle
Ange andra namnet: anders
I bokstavsordning: anders kalle
Övning 1.7:
Skriv ett program som läser in namn och som sedan sorterar dem och skriver ut dem i
bokstavsording, med följande utskrifter:
Hur många namn skall läsas in: 4
Skriv in namn 1: kalle
Skriv in namn 2: eva
Skriv in namn 3: anna
Skriv in namn 4: bengt
875099958
96
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
I bokstavsordning: anna, bengt, eva, kalle,
Övning 1.8:
Skriv ett program som beräknar hypoteunsan med Pythagoras sats avrundad till ett heltal, med
följande utskrift:
Ange ena kateten: 12
Ange andra kateten: 19
Hypotenusan avrundad till heltal: 22
Övning 1.9:
1 1 1 1
1
1
för olika värden på N. Vad blir summan om man
   
 ... 
2 4 8 16 32
N
tar med många termer?
Beräkna summan
875099958
97
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
2. Grafiska metoder
Hittills har programmen körts i konsollfönstret. Java har dock stora grafiska möjligheter. Vi skall
inledningsvis skapa ett fönster. Sedan fyller vi detta med linjer, polygoner och texter via grafiska
metoder. Därefter lär vi oss att hantera grafiska komponenter som knappar och textrutor.
Fönster (frame)
I Java API (Application Programming Interface) finns paketet java.awt (Abstract Window
Toolkit), som innehåller många klasser för hantering av grafik, text, färger och komponenter som
knappar och textrutor. Ur detta paket behöver vi strax klasserna Graphics, Font och Color. Vi
importerar dem därför med följande satser:
import java.awt.Graphics;
import java.awt.Font;
import java.awt.Color;
Eller kortare:
import java.awt.*;
Paketet java.awt innehåller en klass
Frame, som automatiskt öppnar ett fönster
när man skapar ett objekt av klassen. Eftersom vårt program skall ha samma egenskaper som
klassen Frame, måste det ärva Frame:s egenskaper. Följande program skapar ett fönster:
import java.awt.*;
import java.awt.event.*;
//Krävs för stängning av fönster
class anders extends Frame
//extends anger att klassen anders ärver av Frame
{
anders()
//Konstruktor för klassen anders
{
setBackground(Color.yellow);
//Anger fönstrets bakgrundsfärg
setSize(400,150);
//Anger fönstrets storlek
addWindowListener(new WindowAdapter()
//Kryptisk kod som krävs...
{
public void windowClosing(WindowEvent e)
//...för att kunna stänga fönstret...
{
System.exit(0);
//...via systemknappen.
}
});
}
public static void main(String args[]) //Main-funktionen
{
anders d=new anders();
//Skapar objektet d av klassen anders (fönstret skapas)
d.setTitle("Min första frame"); //Text i titelraden
d.setVisible(true);
//Fönstret görs synligt med Frame-metoden setVisible
}
}
Färger
Färgen kan även anges mer fritt på RGB-format. Ett ”färgobjekt” av klassen Color måste då först
skapas:
Color c=new Color(200,0,0);
setBackground(c);
//Skapar objektet c av klassen Color med RGB-färgen (200,0,0) d v s röd
Följande färger finns fördefinierade (anges med Color.):
black, blue, cyan, gray, darkGray, lightGray, green, magenta, orange, pink, red, white, yellow
875099958
98
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Övning 2.1:
Kopiera och modifiera ovanstående programexempel så att bakgrunden får en slumpmässig färg
varje gång fönstret öppnas. Ledning: (int)(255*Math.random()). Programmet fungerar som
http://web.kristinehamn.se/skola/anders/java/ovn2_1.jar.
Övning 2.2:
Modifiera föregående övning ytterligar så att även fönstrets storlek öppnas med slumpmässig
storlek med maximalt 700 pixlar i båda riktningarna. Programmet fungerar som
http://web.kristinehamn.se/skola/anders/java/ovn2_2.jar.
Linje i fönster med metoden paint
Klassen Graphics innehåller grafiska metoder som bl a ritar streck och polygoner, samt text.
Följande program bygger vidare på förra exemplet och ritar en linje i fönstret:
import java.awt.*;
class test4 extends Frame{
test4() {
setBackground(Color.yellow);
setSize(400,400);
}
public void paint(Graphics g){
//Metoden paint anropas automatiskt när fönstret skapas
g.setColor(Color.red);
//Grafikfärg
g.drawLine(100,100,300,300); //Linjen ritas mellan koordinaterna (100, 100) och (300, 300)
}
public static void main(String args[]) {
test4 d=new test4();
d.setVisible(true);
}
}
Observera att metoden paint anropas
automatiskt när fönstret skapas eller ändras.
Metoden paint kan inte anropas, men
omritning av fönster sker med anropet
repaint().
Skapa körbar JAR-fil i Eclipse
1. File -> Export.
2. Java -> JAR file.
3. Markera hela projektet.
4. Välj "Export destination", alltså var JAR-filen
kommer hamna efter exportering.
5. Tryck Next två gånger.
6. Välj klass som ska exporteras till JAR-fil i fältet
"Main Class" .
7. Tryck på Finnish.
Övning 2.3:
Skriv ett program som ritar 1000 slumpmässigt långa
och färgade linjer i ett fönster med storleken 400x400
pixlar. Fönstrets bakgrundsfärg ska vara vit, enligt
urklipp till höger. Programmet fungerar som
http://web.kristinehamn.se/skola/anders/java/ovn2_3.jar.
Svårare uppgift: Rita ut 1000 linjer som är 50 pixlar
långa.
875099958
99
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Text i fönster
Följande program ritar en linje och lägger in text:
import java.awt.*;
class test4 extends Frame{
test4() {
setBackground(Color.yellow);
setSize(400,400);
}
public void paint(Graphics g){
g.setColor(Color.red);
g.drawLine(100,100,300,300);
g.drawString("Det funkar!",200,200); //Skriver ut en textsträng o koordinaten (200, 200)
}
public static void main(String args[]) {
test4 d=new test4();
d.setVisible(true);
}
}
Texten som skriv ut är oformaterad, men kan formateras med klassen Font. Följande rad visar ett
exempel på hur texten kan formateras med Font-variabeln f (objektet f av klassen Font):
Font f=new Font("Arial",Font.BOLD,24);
//Typsnitt (ett fåtal stöds), stil, storlek
För stilen finns även Font.ITALIC och Font.PLAIN. Kombinationer av olika stilar anges med:
Font.BOLD+Font.ITALIC
Följande programexempel illustrerar hur det fungerar genom att modifiera föregående exempel:
import java.awt.*;
class test4 extends Frame{
Font f=new Font("Arial",Font.BOLD,24);
//Objektet f av klassen Font deklareras
test4() {
setBackground(Color.yellow);
setSize(400,400);
}
public void paint(Graphics g){
g.setColor(Color.red);
g.drawLine(100,100,300,300);
g.setColor(Color.green);
//Grafikfärgen ändras för texten
g.setFont(f);
//Den valda fonten sätts
g.drawString("Det funkar!",200,200);
}
public static void main(String args[]) {
test4 d=new test4();
d.setVisible(true);
}
}
875099958
100
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Följande metoder finns för klassen Graphics:
drawLine(x1,y1,x2,y2);
drawRect(x,y,b,h);
fillRect(x,y,b,h);
drawRoundRect(x,y,b,h,m,n)
fillRoundRect(x,y,b,h,m,n)
draw3DRect(x,y,b,h,upp)
fill3DRect(x,y,b,h,upp)
drawOval(x,y,b,h)
fillOval(x,y,b,h)
drawArc(x,y,b,h,s,l)
drawPolygon(xp,yp,n)
fillPolygon(xp,yp,n)
drawString(”Lite text”,x,y)
//Ritar en linje mellan koordinaterna (x1, y1) och (x2, y2)
//Ritar en rektangel med övre vänstra hörnet i (x, y), bredd b och höjd h
//Fyller rektangeln
//Rektangel med rundade hörn, där m och n anger rundning
//Fyller rundad rektangel
//Tredimensionell rektangel, upp är tru elle false
//Fyller en tredimensionell rektangel
//Ritar en oval
//Fyller en oval
//Ritar en båge, där s är startpunkt ock I slitpunkt I grader
//Ritar en polygon. Koordinaterna (n st) ligger i fälten xp och yp
//Fyller polygonen
//Skriver ut ”Lite text” i koordinaten x,y
Övning 2.4:
Modifiera föregående
övning så att fönstret
fylls med 1000
slumpmässigt utritade
och färglagda cirklar
med diametern 20
pixlar i ett 400x400
pixlar stort fönster,
enligt bilden till höger.
Övning 2.5:
Skriv ett program som fyller ett 700x700 pixlar stort fönster
med 50 trianglar med slumpmässig storlek, placering och färg,
enligt urklippet till höger. Programmet fungerar som
http://web.kristinehamn.se/skola/anders/java/ovn2_5.jar.
*Övning 2.6:
Modifiera föregående övning så att fönstret fylls med 10 slumpmässigt utritade och färglagda
lika stora pentagoner (femhörningar). Välj själv polygonens antal hörn och utseende i
programkoden. Fönstrets bakgrundsfärg skall vara grå.
*Övning 2.7:
Skriv ett program som
fyller en 255x255
pixlar stort fönster
med en övertonad
gråskala i x-led från
svart till vitt, enligt
urklppet. En gråskala
erhålls om
färgkomponenterna
R=G=B.
875099958
101
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
*Övning 2.8:
I förra övningen bestämde x-koordinaten gråskalan. Gör en
liknande övertoning, men där funktionen
f  x  y bestämmer gråskalan. Eftersom RGB-färgen f
maximalt är 255 måste funktionen normeras för detta. Om
x y
x och y är maximalt 255 blir f 
255
Programmet fungerar som
http://web.kristinehamn.se/skola/anders/java/ovn2_8.jar.
875099958
102
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Instansvariabler med konstruktor och objekt
I förra exemplet var linjens ändpunkter i paint-metoden fixerade. Vi vill kunna variera
ändpunkternas koordinater är det lämpligt att tilldela dem i main-metoden. Eftersom Java bygger
på klasser måste klassen test4 först få instansvariabler (samma som datamedlemmar i C++) för
ändpunkterna (x1, y1) och (x2, y2), som kan tilldelas antingen via en konstruktor eller via ett
objekt. Nedan visas båda varianterna. Först med konstruktor:
import java.awt.*;
import java.awt.event.*;
class test4 extends Frame{
Font f=new Font("Arial",Font.BOLD,24);
int x1,y1,x2,y2;
//Instansvariabler
test4(int a1,int b1,int a2,int b2) {
//Variablerna tilldelas via konstruktorn
x1=a1; y1=b1; x2=a2; y2=b2;
setBackground(Color.yellow);
setSize(400,400);
}
public void paint(Graphics g){
g.setColor(Color.red);
g.drawLine(x1,y1,x2,y2);
//Instansvariablerna används i metoden paint
g.setColor(Color.green);
g.setFont(f);
g.drawString("Det funkar!",200,200);
}
public static void main(String args[]) {
int x=0, y=50, v=200, w=250;
test4 d=new test4(x,y,v,w);
//Konstruktorn anropas
d.setVisible(true);
}
}
Följande exempel gör samma sak, men här tilldelas instansvariablerna via objektet d:
import java.awt.*;
import java.awt.event.*;
class test4 extends Frame{
Font f=new Font("Arial",Font.BOLD,24);
int x1,y1,x2,y2;
test4() {
setBackground(Color.yellow);
setSize(400,400);
}
public void paint(Graphics g){
g.setColor(Color.red);
g.drawLine(x1,y1,x2,y2);
g.setColor(Color.green);
g.setFont(f);
g.drawString("Det funkar!",200,200);
}
public static void main(String args[]) {
test4 d=new test4();
d.x1=100;
//Instansvariablerna tilldelas via objektet d
d.y1=50;
d.x2=200;
d.y2=350;
d.setVisible(true);
}
}
875099958
103
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Inläsning av variabler
Följande exempel visar hur koordinaterna läses in i main-metoden. Observera att inläsning och
omvandling från string- till int-typ görs i en sats:
import java.awt.*;
import java.io.*;
class test4 extends Frame{
Font f=new Font("Arial",Font.BOLD,24);
int x1,y1,x2,y2;
test4() {
setBackground(Color.yellow);
setSize(400,400);
}
//Objektet f av klassen Font deklareras
public void paint(Graphics g){
g.setColor(Color.red);
g.drawLine(x1,y1,x2,y2);
g.setColor(Color.green);
//Grafikfärgen ändras för texten
g.setFont(f);
//Den valda fonten sätts
g.drawString("Det funkar!",200,200);
}
public static void main(String args[]) throws IOException {
BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
test4 d=new test4();
System.out.print("Ange första x-värdet: ");
d.x1=Integer.parseInt(in.readLine());
//Inläsning och omvandling görs i en sats.
System.out.print("Ange första y-värdet: ");
d.y1=Integer.parseInt(in.readLine());
System.out.print("Ange andra x-värdet: ");
d.x2=Integer.parseInt(in.readLine());
System.out.print("Ange andra y-värdet: ");
d.y2=Integer.parseInt(in.readLine());
d.setVisible(true);
}
}
Övning 2.9:
Skriv ett program som
läser in övre vänstra
hörnets koordinat för en
oval, samt ovalens länd
och bredd och som sedan
ritar den, enligt exemplet
till höger.
875099958
104
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Övning 2.10:
Skriv ett program
som läser in
diametern på en cirkel
och antal fyllda
cirklar som ska ritas
ut, enligt urklippet till
höger.
Övning 2.11:
Skriv ett program som frågar
efter hur många hörn en
polygon skall ha och som sedan
läser in x- och y-koordinater
och ritar/fyller polygonen.
Exemplet till höger visar en
plygon i form av en triangel.
Ledning: Läs in antal hörn och
koordinaterna i main-metoden i
en for-loop:
test4 d=new test4();
System.out.print("Ange antal hörn: ");
d.ant_horn=Integer.parseInt(in.readLine());
for (int i=0;i<d.ant_horn;i++)
{
System.out.print("Ange x-värdet: ");
d.xp[i]=Integer.parseInt(in.readLine());
System.out.print("Ange y-värdet: ");
d.yp[i]=Integer.parseInt(in.readLine());
}
Samt deklarera tre instansvariabler i klassen test4:
int [] xp=new int[10];
int [] yp=new int[10];
int ant_horn;
875099958
//Maximalt tio hörn
//Anger antal hörnpunkter
105
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
3. Applets och grafiska komponenter
På följande Youtubelänkar finns bra lektioner (tutorials) i Java. Följande länk
innehåller grunderna och denna fortsättningen, där kurs 20 inleder med Java Applets.
Han som gjort detta heter thenewboston och har även andra kurser. Hittills har vi
skrivit fristående javaprogram, främst för att lära oss grunderna i språkets syntax.
Ofta används dock javaprogram i samband med webbsidor och då behövs inte JDK:s javatolk för
att köra/interpretera det kompilerade programmet (class-filen), eftersom de vanligaste
webbläsarna kan köra javaprogram – s k javaapplets. En applet (förkortning av applikation) är
alltså ett fristående javaprogram som kan köras av en webbläsare. Detta innebär att
konsolmiljöns inläsningar inte fungerar i applet, där inläsningar istället görs via bl a textrutor.
Detta återkommer vi till senare.
Applets
Koden nedan visa utskrift av klassen Jlabel, som vi gick igenom i kapitel 4 i JavaJavisst:
import javax.swing.*;
import java.awt.*;
public class test4 extends JFrame {
JLabel lbl;
public test4() {
this.setLayout( new FlowLayout() );
lbl = new JLabel("Detta är en JLabel!");
this.add(lbl);
lbl.setFont(new Font("Arial",Font.ITALIC ,20));
lbl.setForeground(Color.yellow);
lbl.setOpaque(true);
lbl.setBackground(Color.blue);
}
public static void main(String[] args) {
test4 f = new test4();
f.setSize(220, 200);
f.setLocation(100,100);
f.setTitle("Med JFrame");
f.setDefaultCloseOperation(test4.EXIT_ON_CLOSE);
f.setVisible(true);
}
}
I följande kod görs samma sak igen, men nu med en javaapplet. För att det ska fungera säkrare i
webbläsaren använder vi inte swing-klasserna, utan endast awt-klasserna. De är här ingen större
skillnad, men än att versalen ’J’ framför komponenterna JLabel, JButton o.s.v. försvinner:
import java.applet.Applet;
importeras
import java.awt.*;
public class testApplet extends Applet{
klassen Applet
//Klassen Applet i paketet applet
//Klassen testApplet ärver från
Label lbl;
public void init() { //Metoden init anropas när testApplet skapas I början
lbl = new Label("Detta är en JLabel!");
this.add(lbl);
lbl.setFont(new Font("Arial",Font.ITALIC ,20));
lbl.setForeground(Color.yellow);
lbl.setBackground(Color.blue);
}
}
875099958
106
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Observera att programmet körs i AppletViewer. Det finns tre huvudsakliga skillnader mellan ett
fristående program och en applet:
1. Istället för från standardklassen Frame ärver klassen testApplet sina egenskaper från
standardklassen Applet, som har liknande egenskapre som Frame. Fönstret som klassen
Applet skapar kan dock inte visas fristående utan webbläsaren.
2. En applet saknar en main-metod. Istället är det webbläsaren som skapar första objektet av
klassen testApplet.
3. Klassen testApplet saknar konstruktor. Initieringar görs istället i metoden init. Fönstrets
storlek anges i webbläsaren.
Programmet kompileras som förut till en class-fil, som exekveras av webbläsaren (se nedan).
Appleten kan dock enkelt testköras med programmet AppletViewer, som körs automatiskt i
Eclipse (eller via Run/Run As/Java Applet). I TextPad körs den via menyvalet Tools/Run
Java Applet. Under menyvalet Applet i AppletViewer finns några funktioner. I webbläsaren körs
appleten med följande HTML-kod:
<html>
<head>
<title> Min hemsida </title>
</head>
<body>
Detta är min hemsida.
<applet code="testApplet.class" width=”500” height=”300”>
</body>
</html>
Attributet code får filnamnet för appleten, och attributen width och height ger fönstrets storlek.
Spara HTML-koden i editeringsprogrammet Anteckningar eller NotePad++ i bin-mappen där
class-filen ligger med filändelsen .html (eller .htm) och öppna filen i webbläsaren genom att
klicka på filen i bin-mappen. Ett bättre alternativ är att spara HTML-koden på motsvarande sätt i
det fria Notepad++, vari webbsidan kan sedan visas via menyvalet Kör/Launch in
Firefox/IE/Chrome. Programmet Notepad++ laddas ner från http://notepad-plus-plus.org.
Prfogrammet ovan är ganska händelselöst. Läggs till följande paint-metod till ritas även grafik.
Paint-metoden anropas när html-filen laddas:
public void paint(Graphics g) {
g.setFont( new Font("Arial",Font.BOLD, 15));
g.setColor( Color.red );
g.drawString("Min applet!", 50, 70);
g.drawOval(10,10,150,150);
g.setColor( new Color(255,100,0));
g.fillOval((int)(100*Math.random()),(int)(100*Math.random()),40,40);
}
Provkör testApplet.class igen i html-filen.
875099958
107
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Övning 3.0:
a) Kopiera koden ovan så att den ritar 100 slumpmässiga linjer. Spara som ovn3_1.java.
b) Kör appleten. Appletviwer visas.
c) Skapa en HTML-fil (webbsida) som kan köra appleten. Spara filen under namnet
hemsida.html i binmappen där class-filen ligger.
d) Prova att öppna webbsidan i de tre olika webbläsarna. Öppnas appleten i alla tre?
e) Experimentera med några olika värden på width och height för appletfönstrets storlek.
Övning 3.1:
Gör på motsvarande sätt appletar och webbsidor som rita slumpmässigt:
a) 100 linger
b) 100 cirklar.
c) 50 trianglar.
d) *som tonar fönstret horisontellt.
e) *som tonar fönstret diagonalt.
Övning 3.2:
a) Gör om några uppgifter till javaapplets du gjort tidigare i avsnitten 0.4 och 0.5 ovan som
innehåller knappar, textrutor och fraktaler. Kolla gärna i kapitel 6 i JavaJavisst.
b) Skapa en html-sida och länka src-filen.
c) Överför html-sidan och src-filen till en webbserver och öppna sidan på Internet med en
webbläsare. Nu kan alla i hela världen köra din applet!
875099958
108
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Parametrar i HTML-koden
Parametrar (variabler) i appleten kan anges i HTML-koden. I följande exempel anges texten som
skall skrivas ut i appleten, samt textens storlek i HTML-koden. Först visas HTML-koden:
<html>
<head>
<!--Kommentar i HTML-->
<title> Min hemsida </title>
</head>
<body>
Detta är min hemsida.
<applet code="test4.class" width=500 height=300>
<param name="t" value="Anders sida"> <!--parametern t får värdet ”Detta är texten”-->
<param name="storlek" value="20">
<!--parametern storlek får värdet 80-->
</body>
</html>
Javaprogrammet läser in värdet på parametrarna t och
storlek från HTML-filen:
import java.applet.Applet;
import java.awt.*;
public class test4_app extends Applet{
Font f;
String text, textstorlek;
int storlek;
public void init() {
textstorlek=getParameter("storlek"); //Värdet på parametern storlek hämtas till textstorlek
storlek=Integer.parseInt(textstorlek);
f=new Font("Arial",Font.BOLD,storlek);
text=getParameter("t");
//Värdet på parametern t hämtas till variabeln text
setBackground(Color.yellow);
}
public void paint(Graphics g){
g.setColor(Color.blue);
g.drawLine(100,100,300,300);
g.setColor(Color.red);
g.setFont(f);
g.drawString(text,50,100);
}
//Grafikfärgen ändras för texten
//Den valda fonten sätts
//Texten skrivs ut via variabeln text
}
All hantering av grafik läggs alltså i metoden paint.
Övning 3.3:
Skriv och provkör en applet som ritar ut ett antal
slumpmässigt placerade fyllda cirklar med
slumpmässig färg. Antalet cirklar och cirklarnas
storlek skall anges som parametrar i HTML-koden.
Modifiera förslagsvis uppgift 2.4. I det förminskade
urklippet till höger är det fem cirklar med diametern
40 pixlar.
875099958
109
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Grafiska komponenter
Kommunikationen med javaprogram sker ofta via grafiska komponenter av samma typ som i
Visual Basic. Java har för detta ett antal standardklasser för grafiska komponenter, såsom t ex
knapp, label (etikett), kryssruta, alternativknapp, listruta, textruta och rullningslist. Samtliga
klasser finns i paketet java.awt.*. Vi kommer nedan att ta upp dessa standardklasser och hur
olika händelser hanteras, t ex knapp- och tangenttryckningar och musklickningar.
Knapp
Knappar skapas av klassen Button. Programmet nedan
innehåller två knappar, som byter till röd respektive grön
färg på bakgrunden:
import java.applet.Applet;
import java.awt.*;
public class test4 extends Applet{
public void init()
{
setBackground(Color.yellow);
Button knappA=new Button("Röd");
add(knappA);
Button knappB=new Button("Grön");
add(knappB);
}
public boolean action(Event evt,Object arg)
{
String text=(String)arg;
if (evt.target instanceof Button)
{
if (text.equals("Röd"))
setBackground(Color.red);
if (text.equals("Grön"))
setBackground(Color.green);
}
return true;
}
//Objektet knappA skapas med texter Röd
//Knappen läggs ut i webbfönstret
//Motsvarande för knapp med text Grön
//action reagerar på en händelse
//arg innehåller knappens (komponentens) text
//evt kollar typ av komponent (klass)
}
Observera att knapparna centreras i fönstret från vänster i den ordning de skapas. Senare kommer
vi att placera ut dem på ett sätt vi själva väljer. Vi modifierar programmet så att en slumpmässig
färg används när knappB aktiveras. Koden för detta läggs lämpligen i en egen metod slumpfarg.
Programmet får då följande utseende:
import java.applet.Applet;
import java.awt.*;
public class test4 extends Applet{
public void init() {
setBackground(Color.yellow);
Button knappA=new Button("Röd");
add(knappA);
Button knappB=new Button("Slumpfärg");
add(knappB);
}
public void slumpfarg(){
int r=(int)Math.round(255*Math.random());
875099958
110
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
int g=(int)Math.round(255*Math.random());
int b=(int)Math.round(255*Math.random());
Color c=new Color(r,g,b);
setBackground(c);
}
public boolean action(Event evt,Object arg){
String text=(String)arg;
if (evt.target instanceof Button){
if (text.equals("Röd"))
setBackground(Color.red);
if (text.equals("Slumpfärg"))
slumpfarg();
}
return true;
}
}
Klassen Button har två konstruktorer för knappen k:
Button k=new Button();
Button k=new Button(”Tryck”);
//Ger en textlös knapp
//Ger knappen texten Tryck
Nedan visas några användbara metoder för knappen k:
k.setLabel(”Text”);
String texten=k.getLabel();
//Placerar texten Text på knappen
//Returnerar knapptexten till variabeln texten
Textruta
Textrutor skapas av klassen TextField. I programmet nedan färgas bakgrunden av den färg (r, g,
b, y) som matas in i textrutan:
import java.applet.Applet;
import java.awt.*;
public class test4 extends Applet{
TextField rutan1; //rutan1 global
public void init() {
setBackground(Color.yellow);
Button knappA=new Button("Textfärg");
add(knappA);
Button knappB=new Button("Slumpfärg");
add(knappB);
rutan1=new TextField("Skriv här",10);
add(rutan1);
}
//Objektet rutan1 skapas
//Placerar textrutan I fönstret
public void slumpfarg(){
int r=(int)Math.round(255*Math.random());
int g=(int)Math.round(255*Math.random());
int b=(int)Math.round(255*Math.random());
Color c=new Color(r,g,b);
setBackground(c);
}
public void textfarg(){
if (rutan1.getText().equals("g"))
setBackground(Color.green);
if (rutan1.getText().equals("r"))
setBackground(Color.red);
if (rutan1.getText().equals("b"))
875099958
111
//Metoden getText() returnerar texten i textrutan
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
setBackground(Color.blue);
if (rutan1.getText().equals("y"))
setBackground(Color.yellow);
}
public boolean action(Event evt,Object arg){
String text=(String)arg;
if (evt.target instanceof Button){
if (text.equals("Textfärg"))
textfarg();
if (text.equals("Slumpfärg"))
slumpfarg();
}
return true;
}
//Metoden textfärg anropas
}
Klassen TextField har några olika konstruktorer för en textruta t:
TextField t=new TextField();
TextField t=new TextField(10);
TextField t=new TextField("Skriv här");
TextField t=new TextField("Skriv här",n);
//Ger ett tomt textfält
//Ger ett textfält med plats för 10 tecken
//Ger ett textfält med texten ”Skriv här”
//Ger ett textfält med texten ”Skriv här” och med n positioner
Nedan visas några användbara metoder för textrutan t:
t.SetColumns(n)
String texten=t.getText();
t.SetText(”Detta står i textrutan”);
t.setEchoChar(’*’);
t.selectAll();
t.select(i,j);
texten=t.getSelectedText();
//Antal teckenpositioner sätts till n
//Textrutans innehåll returneras alltid som typen String
//Tilldelar textrutan en text
//Hemlig text, en ’*’ visas istället för tecknen
//All text markeras
//Tecknen i till j markeras
//Returnerar markerad text
Etikett (label)
Etiketter skapas av klassen Label. I programmet nedan skrivs innehållet i textrutan ut
högerjusterat i en label när knappen aktiveras:
import java.applet.Applet;
import java.awt.*;
public class test4 extends Applet{
TextField te;
Label la;
public void init() {
setBackground(Color.yellow);
Button knappA=new Button("Tryck");
add(knappA);
te=new TextField("Skriv här",10);
add(te);
la=new Label("Detta är en label",Label.RIGHT);
//Etiketten la skapas högerjusterad
add(la);
}
public boolean action(Event evt,Object arg){
String text=(String)arg;
if (evt.target instanceof Button){
if (text.equals("Tryck"))
la.setText(te.getText());
//Texten i textrutan tilldelas etiketten
}
return true;
}
}
875099958
112
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Klassen Label har två konstruktorer för etiketten e:
Label e=new Label(”Text i etikett”);
Label e=new Label(”Text i etikett”,Label.RIGHT);
//Skriver ut texten vänsterjusterad i etikettens textyta
//Skriver ut texten högerjusterad; Label.RIGHT,
//Label.LEFT och Label.CENTER finns
Nedan visas några användbara metoder för etiketten e:
e.setText(”Text”);
String texten=e.getText();
e.setAligment(Label.CENTER);
//Placerar texten Text i etiketten
//Returnerar etiketttexten till variabeln texten
//Centrerar texten
Egenskaper hos komponenter
Komponenternas färg, text, storlek och läge kan påverkas av bl.a. samma metoder som vi använt
för hela fönstret:
setBackground(c);
setForegrund(c);
setFont(f);
setVisible(true/false);
setSize(bredd, höjd);
setLocation(x,y);
//Påverkar bakgrundsfärg hos text och knapp
//Påverkar textfärg
//Anger textstil och storlek
//Komponenten döljs med false
//Anger komponentens bredd och höjd i pixlar. Görs efter initieringen i t ex paint
//Placerar komponenten med övre vänstra hörnet i koordinaten (x,y) i t ex paint
Nedan visas några exempel på färg- och textändringar för knapp, textruta och etikett:
TextField t = new TextField("Skriv här!",10);
Label e = new Label("Grön:",Label.RIGHT);
Button b = new Button("Tryck");
Font f=new Font("Arial",Font.BOLD,24);
Color c=new Color(200,200,0);
e.setFont(f);
//Etikettens text anges
b.setVisible(false);
//Knappen döljs
e.setForeground(Color.green);
//Etikettens text blir grön
e.setBackground(c);
//Etikettens bakgrund får färgen c
t.setBackground(Color.blue);
//Textrutans bakgrundsfärg blir blå
e.setSize(50,15);
//Etiketten får längden 50 och höjden 15 pixlar
e.setLocation(10,100);
//Lägger etiketten med övre vänstra hörnet i koordinaten (10,100)
Övning 3.2:
Skriv och kör en applet via ett HTML-dokument läser in och
beräknar summan av två decimaltal, enligt urklippet intill.
Ledning: Använd Double.parseDouble(text); för omvandling från
text till double och String.valueOf(x) för omvandling från typen
double till text. Körning via applet:
http://web.kristinehamn.se/skola/anders/java/ovn3_2.html.
Övning 3.3:
Modifiera föregående applet så att den istället beräknar hypotenusan till två inmatade kateter.
875099958
113
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Övning 3.4:
Skriv ett program där bakgrundsfärgen anges i tre textrutor på
RGB-format (0-255). Använd Integer.parseInt(x); för
omvandling från text till heltal. Följande skall gälla (se även
urklipp):

Textfärgen på etiketten och i textrutan skall vara röd,
grön respektive blå.

Etiketternas bakgrundsfärg skall vara samma som
fönstrets bakgrundsfärg. Texten skall vara 24 p fet.

Anropa appleten via en hemsida, exempelvis så här:
http://web.kristinehamn.se/skola/anders/java/ovn3_4.html
Övning 3.5:
Gör HiLo-spel i form av
en javaapplet, d.v.s
appleten genererar ett
slumptal som man ska
försöka att gissa rätt på.
Programmet räknar även
antalet gissningar och
det fungerar enligt http://web.kristinehamn.se/skola/anders/java/ovn3_5.html.
Rullningslist (scrollbar)
Rullningslisten skapas av klassen Scrollbar. I programmet nedan skrivs läget hos rullningslisten
ut i en etikett:
import java.applet.Applet;
import java.awt.*;
public class test4 extends Applet{
Label la;
Scrollbar rull;
public void init() {
setBackground(Color.yellow);
rull=new Scrollbar(Scrollbar.HORIZONTAL,50,10,0,110); //Rullningslistens konstruktor
add(rull);
la=new Label("50",Label.RIGHT);
add(la);
}
public boolean handleEvent(Event evt){
//handleEvent hanterar händelser från rullningslist
if (evt.target instanceof Scrollbar)
la.setText(String.valueOf(rull.getValue())); //Läget hos rullningslisten skrivs ut i label
return true;
}
}
Observera att metoden action inte fungerar för rullningslister. Istället används metoden
handleEvent. Klassen Scrollbar har följande konstruktor för rullningslisten r:
Scrollbar r=new Scrollbar(Scrollbar.HORIZONTAL,position,knappbredd,min,max);
875099958
114
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Positionen avläses vid knappens vänstra sida (undre sida vid Scrollbar.VERTICAL). Om
exempelvis min=0, max=100 och knappbredd=10 blir maximala positionen 90 när knappen
ligger längst till höger. Nedan visas några användbara metoder för rullningslisten r:
r.getValue();
r.setValue(n);
r.getMaximum()
r.getMinimum()
//Ger position hos rullningslistens knapp som heltal
//Sätter rullningslistens knapp till positionen n (heltal, även negativt)
//Ger maxvärdet
//Ger minvärdet
Övning 3.6:
Skriv ett program med tre rullningslister, med vilka
bakgrundsfärgen kan justeras (0-255). Vald färg
skrivs ut i respektive etikett på RGB-form.
Etikettfärgen skall dessutom vara röd, grön och blå,
samt deras bakgrundsfärg samma som fönstrets
bakgrundsfärg, enligt urklippet till höger. Appleten
fungerar enligt
http://web.kristinehamn.se/skola/anders/java/ovn3_
6.html.
Övning 3.7:
Skriv en applet som ritar ett antal
slumpmässigt utplacerade cirklar,
enligt urklippet till höger. Cirklarnas
diameter (0-100 pixlar) och antal (0100) anges med två rullningslister.
Ritningen sker i metoden paint, som
anrops med metoden repaint().
Appleten fungerar enligt
http://web.kristinehamn.se/skola/ander
s/java/ovn3_7.html.
875099958
115
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
4. Mus- och tangenthändelser
I förra kapitlet hanterades händelser vid knapptryckningar och ändringar hos en rullningslist. I
detta kapitel skall vi ta hand om händelser hos mus och tangenter.
Mushändelser
Följande metoder hanterar händelser hos musen:
mouseDown(Event evt, int x, int y)
mouseUp(Event evt, int x, int y)
mouseMove(Event evt, int x, int y)
mouseDrag(Event evt, int x, int y)
mouseEnter(Event evt, int x, int y)
mouseExit(Event evt, int x, int y)
//Ger markörens koordinat när en musknapp trycks ned
//Ger markörens koordinat när en musknapp släpps upp
//Ger markörens koordinat när musen rör sig
//Samma som föregående, men när en musknapp är nedtryckt
//Ger markörens koordinat när musen kommer in i fönstret
//Ger markörens koordinat när musen lämnar fönstret
Programmet nedan skriver ut markörens koordinat när musknappen trycks ned, släpps upp
respektive när musen rör sig i tre olika etiketter:
import java.applet.Applet;
import java.awt.*;
public class test4 extends Applet{
Label l1,l2,l3;
public void init() {
l1=new Label("MouseDown x=000 y=000",Label.LEFT);
add(l1);
l2=new Label("MouseUp x=000 y=000",Label.LEFT);
add(l2);
l3=new Label("MouseMove x=000 y=000",Label.LEFT);
add(l3);
}
public boolean mouseDown(Event evt, int x, int y){
l1.setText("MouseDown x="+String.valueOf(x)+" y="+String.valueOf(y));
return true;
}
public boolean mouseUp(Event evt, int x, int y){
l2.setText("MouseUp x="+String.valueOf(x)+" y="+String.valueOf(y));
return true;
}
public boolean mouseMove(Event evt, int x, int y){
l3.setText("MouseMove x="+String.valueOf(x)+" y="+String.valueOf(y));
return true;
}
}
875099958
116
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Override på update
Följande program skriver ut markörens koordinat med ritmetoden drawString där musknappen
trycks ned:
import java.applet.Applet;
import java.awt.*;
public class test4 extends Applet{
int x1,y1;
//Globala variabler
public void paint(Graphics g){
g.drawString("x="+String.valueOf(x1)+" y="+String.valueOf(y1),x1,y1);
}
public boolean mouseDown(Event evt, int x, int y){
x1=x;
y1=y;
repaint();
//Anropar metoden paint
return true;
}
}
Observera att den gamla koordinaten raderas vid varje ny musklickning. Detta beror på att
metoden repaint även anropar metoden update, som målar över all grafik (dock inte
komponenter som knappar och etiketter) med bakgrundsfärgen. Genom att göra en
omdefiniering av update så att den anropar paint utan att rita om bakgrunden, kommer även de
gamla koordinaterna att visas. Att omdefiniera en metod kallas override. Följande program visar
hur det fungerar:
import java.applet.Applet;
import java.awt.*;
public class test4 extends Applet{
int x1=50, y1=50;
//Startkoordinater för paint, som anropas när fönstret skapas
public void paint(Graphics g){
g.drawString("x="+String.valueOf(x1)+" y="+String.valueOf(y1),x1,y1);
}
public void update(Graphics g){
paint(g);
}
//override på update
public boolean mouseDown(Event evt, int x, int y){
x1=x;
y1=y;
repaint();
return true;
}
}
Originalversionen av update har följande utseende:
public void update(Graphics g){
g.setColor(getBackground());
g.fillRect(0,0,width,height);
g.setColor(getForeground());
paint(g);
}
875099958
117
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Övning 4.1:
Skriv ett program som ritar ut en röd cirkel med diametern
20 punkter när musknappen klickas, enligt urklippet.
Appleten fungerar enligt
http://web.kristinehamn.se/skola/anders/java/ovn4_1.html.
Övning 4.2:
Skriv ett program som ritar en linje mellan två punkter som
klickar med musen. Appleten fungerar enligt
http://web.kristinehamn.se/skola/anders/java/ovn4_2.html.
Övning 4.3:
Skriv ett program som ritar en gul rektangel
med röd ram med diagonalen mellan de två
klickade punkterna. Observera att rekrangeln
omges av en röd linje, samt att det inte spelar
någon roll hur punkterna klickas, d v s om
nedre eller övre punkten klickas först. Ledning: Använd funktionerna Math.min() och
Math.abs(). Appleten fungerar enligt http://web.kristinehamn.se/skola/anders/java/ovn4_3.html.
*Övning 4.4:
Modifiera föregående övning så att rektangeln ritas ut i ’realtid’ med musknappen nedtryckt. Det
skall även fungera att minska rektangelns storlek. När musknappen släpps och en ny
rektangelpåbörjas raderas den gamla. Ledning: Gör inte override på update. Appleten fungerar
enligt http://web.kristinehamn.se/skola/anders/java/ovn4_4.html.
Övning 4.5:
Skriv ett program där man kan rita med musen när en knapp
är nedtryckt. Appleten fungerar enligt
http://web.kristinehamn.se/skola/anders/java/ovn4_5.html.
875099958
118
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Rita utan paint
Metoden paint anropas automatiskt när appleten startas. Ibland ställer detta till problem, t ex när
variabler i paint ännu inte är initierade. Därför är det bättre att lägga kod som ritar figurer i en
egendefinierad metod, som anropas från t ex en musmetod. Detta illustreras i följande exempel,
där en kvadrat ritas ut vid varje musklickning. Programmet innehåller även en knapp som raderar
fönstret:
import java.applet.Applet;
import java.awt.*;
public class test4 extends Applet{
Button knapp;
//Raderaknappen
Graphics g;
//Deklarera objektet g av klassen Graphics
public void init() {
g=getGraphics(); //Skapar objektet g. Observera get istället för new
setBackground(Color.yellow);
knapp=new Button("Radera");
add(knapp);
}
public boolean action(Event evt,Object arg){
repaint();
return true;
}
//Reagerar på knappen
//Ritar om fönstret, d v s raderar
public void rita(int x1, int y1){
g.setColor(Color.red);
g.fillRect(x1-10,y1-10,20,20);
}
//Egen metod rita som ritar
//Fyller en rektangel med markör i mitten
public boolean mouseDown(Event evt, int x, int y){
rita(x,y);
//Anropar egna funktionen rita. Skickar med x och y.
return true;
}
}
Observera att programmet innehåller den egendefinerade metoden rita, som ritar ut en kvadrat.
Övning 4.6:
Modifiera exemplet ovan så att fönstret raderas om markören klickar på en koordinat då x<5 och
y<5 eller om markören ligger utanför fönstret (använd mouseExit). Appleten fungerar enligt
http://web.kristinehamn.se/skola/anders/java/ovn4_6.html.
Övning 4.7:
Skriv ett program där man kan rita polygoner genom att klicka
i hörnen med musen. Polygonen ritas när det sista hörnet
klickas. Antal hörn matas in i textrutan. Det skall även finnas
en knapp som raderar fönstret. Appleten fungerar enligt
http://web.kristinehamn.se/skola/anders/java/ovn4_7.html.
875099958
119
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Tangenthändelser
Händelserna keyDown(Event evt, int key) och KeyUp(Event evt, int key) hanterar
tangenttryckningar. Parametern key anger ASCII-koden för den nedtryckta tangenten och evt
används för att kolla om Alt-, Ctrl- eller Skift-tangenten är nedtryckt:
if (evt.controlDown())
if (evt.shiftDown())
if (evt.metaDown())
//true om Ctrl-tangen är nedtryckt
//true om Skift-tangen är nedtryckt
//true om Alt-tangen är nedtryckt
Följande exempel skriver ut ASCII-koden och tecknet för den nedtryckta tangenten:
import java.applet.Applet;
import java.awt.*;
public class test3 extends Applet{
String s="";
public void paint(Graphics g){
g.drawString(s,50,50);
}
public boolean keyDown(Event evt, int key){
s="ASCII-kod: "+String.valueOf(key)+" Tecken: "+(char)key;
repaint();
return true;
}
}
Observera att man måste klicka på appleten med musen en gång innan tangenthändelserna
aktiveras. Det går heller inte att använda tangenthändelserna för att skriva ut text i
komponenterna textrura och etikett. För vissa tangenter som saknar ASCII-kod, t ex
piltangenterna, finns specialtecken:
Event.HOME
Event.END
Event.PGUP
Event.PGDN
Event.UP
Event.DOWN
Event.LEFT
Event.RIGHT
//Home-tangenten
//End-tangenten
//Page Up-tangenten
//Page Down-tangenten
//Pil upp-tangenten
//Pil ned-tangenten
//Pil vänster-tangenten
//Pil höger-tangenten
Specialtecknen används på följande sätt:
if(key==Event.LEFT)
//Kollar om tangenten för pil vänster är nedtryckt
Övning 4.8:
Gör en applet där du kan flytta runt en kvadrat på skärmen med piltangenterna.
Övning 4.9:
Gör en applet där du kan rita en figur med pitangenterna med en liten punkt som penna. Trycker
man på ’f’-tangenten kan flytta punkten på skärmen utan att det ritas ett streck. Trycker man på
’r’-tangenten ritar punkten ett streck efter sig när den flyttas.
875099958
120
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
5. Animering med trådar
Innan vi börjar animera skall vi presentera sex huvudmetoder som finns i klassen Applet (utom
run). Två av dem, init och paint, har vi använt tidigare:
init()
Detta är den första metoden som körs när appleten laddas i webbläsaren.
Här görs initieringar av t ex komponenter, globala variabler och av
bakgrundsfärg.
start()
Efter att init anropats körs metoden start. Den används för att starta någon
aktivitet, t ex en animering (se nedan).
run()
Metoden anropas efter att en aktivitet startats i metoden start, t ex att en tråd
har startats (finns i gränssnittet Runnable, se nedan).
stop()
…kan användas för att stoppa en aktivitet. Metoden anropas automatisk när
användaren lämnar webbsidan. Metoden används sällan i program.
paint(Graphics g) Här placeras grafikrutinera för att rita på appleten. Metoden anropas
automatiskt när appleten startas och när fönstrets storlek eller läge
förändras. I tidigare exempel (s. 30) har vi visat hur man kan rita utan paint
genom att deklarera en egen metod.
destroy()
Denna metod anropas automatiskt när appleten avslutas och webbfönstret
stängs och frigör då allt allokerat minne. Metoden används sällan i program.
Trådar och multitasking
När ett program befinner sig i en loop är det normalt helt uppslukat av vad som händer i loopen
och kan inte påverkas utifrån. Exempelvis går det inte att avbryta en loop via en knapptryckning.
Med trådar (threads) kan man emellertid använda sig av s k multitasking, d v s programmet får
då förmågan att reagera på yttre händelser trots att det är upptaget av en loop. För att detta skall
fungera i Java måste vi införa gränssnittet Runnable, som innehåller metoder för trådar. Först
något om multipelt arv i Java.
Multipelt arv och gränssnitt i Java
I C++ använde vi ibland multipelt arv. Detta innebär att en klass kan ärva från flera klasser. I
Java däremot kan en klass ärva från endast en klass (via extends). Java har dock begreppet
gränssnitt, som är en samling av metoder som kan ’ärvas’ via kommandot implements.
Klassen Thread och gränssnittet Runnable
Klassen Thread har några metoder för att starta och stänga av trådar:
Thread trad;
trad.start();
trad.stop();
trad.suspend();
trad.resume();
Startar en tråd
Stoppar en tråd
Deaktiverar en tråd, d v s pausar tråden
Återstartar en deaktiverad tråd
Observera att dessa start och stop inte är samma som tillhör klassen Applet. I följande exempel
ärver klassen test4 egenskaperna från klassen Applet, samt implementerar gränssnittet Runnable,
875099958
121
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
som innehåller metoden run. Programmet flyttar en cirkel över skärmen, som kan placeras där
markören klickas. Animeringen kan pausas och omstartas:
875099958
122
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
import java.applet.Applet;
import java.awt.*;
public class tradar extends Applet implements Runnable{
Thread trad;
int x1=10,y1=100;
Button start,stopp;
public void init() {
start=new Button("Starta");
stopp=new Button("Stoppa");
add(stopp);
add(start);
trad=new Thread(this);
}
public void start(){
trad.start();
}
public void run(){
while (true)
{
x1++;
repaint();
try {Thread.sleep(5);}
catch (InterruptedException e){}
}
}
//Metoden paint anropas när fönstret ritas om.
//Skapar en fördröjning på 10 ms
public void paint(Graphics g){
g.fillOval(x1,y1,20,20);
}
public boolean action(Event evt,Object arg){
String text=(String)arg;
if (evt.target instanceof Button)
if (text.equals("Stoppa"))
trad.suspend();
if (text.equals("Starta"))
trad.resume();
return true;
}
public boolean mouseDown(Event evt, int x, int y){
x1=x;
y1=y;
return true;
}
//Flyttar cirkel till koordinat x1, y1.
}
Övning 5.1:
Gör en applet som flyttar runt en cirkel slumpmässigt på skärmen med en fördröjning på 100 ms.
Appleten fungerar enligt http://web.kristinehamn.se/skola/anders/java/ovn5_1.html.
Övning 5.2:
Modifiera föregående program så att flyttningen kan startas respektive stoppas via två knappar.
Appleten fungerar enligt http://web.kristinehamn.se/skola/anders/java/ovn5_2.html.
875099958
123
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Övning 5.3:
Gör en applet som ändrar bakgrundsfärgen från rött till blått via en animering. Appleten fungerar
enligt http://web.kristinehamn.se/skola/anders/java/ovn5_3.html.
Två trådar
Vitsen med trådar är ju att kunna köra flera processer samtidigt. Följande exempel visar hur två
trådar ’processar’ två bollar oberoende av varandra. Metoden i metoden run avgör vilket tråd
som för tillfället är aktiv. Bollarna startas (resume) och stoppas (suspend) med var sin knapp:
import java.applet.Applet;
import java.awt.*;
public class test3 extends Applet implements Runnable{
Thread trad1,trad2;
int x1=50,y1=50,x2=100,y2=100,paus;
Button start,stopp;
boolean tryck1=false, tryck2=false;
public void init() {
start=new Button("Blå");
stopp=new Button("Röd");
add(stopp);
add(start);
trad1=new Thread(this);
trad2=new Thread(this);
}
public void start(){
trad1.start();
trad1.suspend();
trad2.start();
trad2.suspend();
}
public void stop(){
trad1.stop();
trad2.stop();
}
public void run(){
while (true){
if (Thread.currentThread().equals(trad1)){
x1=(int)Math.round(300*Math.random());
y1=(int)Math.round(300*Math.random());
paus=1000;
}
if (Thread.currentThread().equals(trad2)){
x2=(int)Math.round(300*Math.random());
y2=(int)Math.round(300*Math.random());
paus=500;
}
repaint();
try {Thread.sleep(paus);}
catch (InterruptedException e){}
}
}
public void paint(Graphics g){
g.setColor(Color.red);
g.fillOval(x1,y1,20,20);
g.setColor(Color.blue);
g.fillOval(x2,y2,20,20);
}
public boolean action(Event evt,Object arg){
875099958
124
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
String text=(String)arg;
if (evt.target instanceof Button)
if (text.equals("Röd")){
tryck1=!tryck1;
if (tryck1)
trad1.resume();
else
trad1.suspend();
}
if (text.equals("Blå")){
tryck2=!tryck2;
if (tryck2)
trad2.resume();
else
trad2.suspend();
}
return true;
}
}
Trådar i egen klass
I förra exemplet kördes de båda trådarna i samma run-metod i appleten. Detta är en liten
’halvdan’ parallellprocessering, eftersom trådarna startas samtidigt när run-metoden anropas.
Genom att köra trådarna via en klass blir det mer uppenbart att trådarna exeveras parallellt.
Följande program fungerar som förra exemplet. Programmet använder dock den egna klassen
Boll för trådar och grafik, samt inte gränssnittet Runnable:
import java.applet.Applet;
import java.awt.*;
public class test3 extends Applet {
public class Boll extends Thread{
private int x,y,tid;
private Graphics gr=getGraphics();
private Color farg;
Boll (int a,int b,Color f,int t){
x=a;
y=b;
farg=f;
tid=t;
}
}
//Egna klassen Boll ärver från klassen Thread
//Konstruktor för klassen Boll
public void run() {
while (true){
x++;
gr.setColor(farg);
gr.fillOval(x,y,20,20);
try {Thread.sleep(tid);}
catch (InterruptedException e){}
gr.setColor(Color.white);
//Raderar och ritar om utan repaint
gr.fillOval(x,y,20,20);
if (x>getWidth())
//Ger fönstrets bredd
x=0;
}
}
//Definitionen för klassen Boll slutar
Boll b1, b2;
Button knappb, knappr;
875099958
//Två Boll-objekt deklareras
125
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
boolean tryck1=false, tryck2=false;
public void init() {
knappb=new Button("Blå");
knappr=new Button("Röd");
add(knappb);
add(knappr);
b1=new Boll(0,100,Color.red,10);
b1.start();
b1.suspend();
b2=new Boll(0,200,Color.blue,20);
b2.start();
b2.suspend();
}
public boolean action(Event evt,Object arg){
String text=(String)arg;
if (evt.target instanceof Button)
if (text.equals("Röd")){
tryck1=!tryck1;
if (tryck1)
b1.resume();
else
b1.suspend();
}
if (text.equals("Blå")){
tryck2=!tryck2;
if (tryck2)
b2.resume();
else
b2.suspend();
}
return true;
}
public void stop(){
b1.stop();
b2.stop();
}
}
Observera att bollarna raderas genom att de ritas om med bakgrundsfärgen innan de ritas i en ny
position. Genom att inte använda repaint minskas flimret i animeringen.
Övning 5.4:
Modifiera exemplet ovan och gör så att en eller några bollar studsar med olika fart mellan
fönstrets sidor.
Övning 5.5:
Gör en applet som innehåller 20 studsande bollar mellan fönstrets sidor. Skapa bollarna via en
array och använd klassen Boll i föregående exempel. Bollarnas färg, fart och startposition skall
vara slumpmässig. Låt gärna den slumpmässiga färgen i genereras i klassen Boll.
875099958
126
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
6. Klasser i egna filer
Följande exempel använder klassen Test för att skriva ut en sträng. Klassen innehåller även två
konstruktorer; en med och en utan parameter:
import java.applet.Applet;
import java.awt.*;
public class test3 extends Applet{
public class Test{
private String namn;
//Klassen Test definieras
//Instansvariabeln namn deklareras
public Test(String n){
namn=n;
}
//Konstruktor med parameter
public Test(){
namn="Kalle Anka";
}
//Konstruktor utan parameter
public String skriv_namn(){
return namn;
}
//Metod skriv_namn för utskrift av variabeln namn definieras
}
//Slut på klassdefinitionen
Test t1,t2;
public void init() {
t1=new Test();
t2=new Test("Musse Pigg");
}
//Referensvariablerna (objekten) t1 och t2 deklareras
//t1 initieras till att referera till ett objekt av klassen Test
//t1 och t2 är en instans av klassen Test
public void paint(Graphics g){
g.drawString(t1.skriv_namn()+" och "+t2.skriv_namn(),100,100);
}
}
Egen klassfil
Vi modifierar föregående program genom att spara klassen Test i filen Test.java och kompilera
den i samma mapp som appleten test3.java. Programmet blir då något kortare:
import java.applet.Applet;
import java.awt.*;
public class test3 extends Applet{
Test t1,t2;
public void init() {
t1=new Test();
t2=new Test("Musse Pigg");
}
public void paint(Graphics g){
g.drawString(t1.skriv_namn()+" och "+t2.skriv_namn(),100,100);
}
}
875099958
127
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Lösningar
Övning 3.2:
import java.applet.Applet;
import java.awt.*;
public class knappar extends Applet{
TextField t1, t2;
Label l1, l2, l3;
public void init() {
setBackground(Color.yellow);
l1=new Label("Ange tal 1:",Label.RIGHT);
add(l1);
t1=new TextField("Skriv här",10);
add(t1);
l2=new Label("Ange tal 2:",Label.RIGHT);
add(l2);
t2=new TextField("Skriv här",10);
add(t2);
Button knappA=new Button("Tryck");
add(knappA);
l3=new Label("
",Label.RIGHT);
add(l3);
}
public void berakna(){
double tal1=Double.parseDouble(t1.getText());
double tal2=Double.parseDouble(t2.getText());
l3.setText(String.valueOf(tal1+tal2));
}
public boolean action(Event evt,Object arg){
String text=(String)arg;
if (evt.target instanceof Button){
if (text.equals("Tryck"))
berakna();
}
return true;
}
}
875099958
128
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Övning 3.4:
import java.applet.Applet;
import java.awt.*;
public class ovn3_4 extends Applet{
TextField t1, t2, t3;
Label l1, l2, l3;
public void init() {
//setBackground(Color.yellow);
Font f=new Font("Arial",Font.BOLD,24);
l1=new Label("Röd",Label.RIGHT);
//Etiketten la skapas högerjusterad
l1.setFont(f);
l1.setForeground(Color.red);
add(l1);
t1=new TextField("Skriv här",10);
t1.setFont(f);
t1.setForeground(Color.red);
add(t1);
l2=new Label("Grön",Label.RIGHT);
l2.setFont(f);
l2.setForeground(Color.green);
add(l2);
t2=new TextField("Skriv här",10);
t2.setFont(f);
t2.setForeground(Color.green);
add(t2);
l3=new Label("Blå",Label.RIGHT);
l3.setFont(f);
l3.setForeground(Color.blue);
add(l3);
t3=new TextField("Skriv här",10);
t3.setFont(f);
t3.setForeground(Color.blue);
add(t3);
Button knappA=new Button("Tryck");
add(knappA);
}
public void berakna(){
int r=Integer.parseInt(t1.getText());
int g=Integer.parseInt(t2.getText());
int b=Integer.parseInt(t3.getText());
Color c=new Color(r,g,b);
setBackground(c);
l1.setBackground(c);
l2.setBackground(c);
l3.setBackground(c);
}
public boolean action(Event evt,Object arg){
String text=(String)arg;
if (evt.target instanceof Button){
if (text.equals("Tryck"))
berakna();
}
return true;
}
}
875099958
129
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
Övning 0.13.20 (klicka ballonger). Programmet Klicka_cirkel.java, samt klassen Cirkel3.java:
public class Klicka_cirkel extends JPanel implements ActionListener, MouseListener {
Cirkel3 c[] = new Cirkel3[5];
Timer t;
String s;
double tid=0;
int x=20,y=20;
Font f=new Font("Arial",Font.BOLD,17);
public Klicka_cirkel() {
setBackground(Color.black);
for (int i = 0; i <= 4; i++)
c[i] = new Cirkel3();
t = new Timer(30, this);
t.start();
Cirkel3.antalboll=5;
this.addMouseListener(this);
}
public void paintComponent(Graphics g) {
super.paintComponent(g);
g.setFont(f);
for (int i = 0; i <= 4; i++)
c[i].visa(g);
tid=tid+0.03;
g.setColor(Color.yellow);
if (Cirkel3.antalboll==0){
t.stop();
g.drawString("Tid: "+String.format("%4.2f",tid)+" s. Slut!",10,30);
}
else
g.drawString("Tid: "+String.format("%4.2f",tid)+" s. Antal bollar kvar: " +
Cirkel3.antalboll, 10, 30);
}
public void actionPerformed(ActionEvent arg0) {
for (int i = 0; i <= 4; i++) {
c[i].nyPosition();
repaint();
}
}
public void mousePressed(MouseEvent e) {
x=e.getX();
y=e.getY();
for (int i = 0; i <= 4; i++)
c[i].kolla(x,y);
repaint();
}
public static void main(String[] args) {
JFrame f = new JFrame();
f.setSize(300, 300);
f.setLocation(100, 100);
f.setTitle("Klicka_cirkel");
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Klicka_cirkel p = new Klicka_cirkel();
f.add(p);
f.setVisible(true);
}
875099958
130
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
@Override
public void mouseEntered(MouseEvent e) {
// TODO Auto-generated method stub
}
@Override
public void mouseExited(MouseEvent e) {
// TODO Auto-generated method stub
}
@Override
public void mouseClicked(MouseEvent e) {
// TODO Auto-generated method stub
}
@Override
public void mouseReleased(MouseEvent e) {
// TODO Auto-generated method stub
}
}
Klass Cirkel3.java:
import java.applet.Applet;
import java.applet.AudioClip;
import java.awt.Color;
import java.awt.Graphics;
public class Cirkel3 {
private int xpos, ypos, diam, dx = 6, dy = 2;
Color c;
private boolean traffad = false;
public static int antalboll;
AudioClip ac;
public Cirkel3() {
xpos = (int) Math.ceil(230 * Math.random());
ypos = (int) Math.ceil(230 * Math.random());
diam = 10 + (int) Math.ceil(50 * Math.random());
c = new Color((int) (255 * Math.random()), (int) (255 * Math.random()),
(int) (255 * Math.random()));
}
public void visa(Graphics g) {
if (!traffad) {
g.setColor(c);
g.fillOval(xpos, ypos, diam, diam);
}
}
public void kolla(int xp, int yp) {
if (!traffad && xp > xpos && xp < xpos + diam && yp > ypos && yp <ypos+diam){
antalboll--;
traffad=true;
try{
ac = Applet.newAudioClip(new java.net.URL("file:traff.au"));
}
875099958
131
Brogårdsgymnasiet
LEKTIONSGENOMGÅNGAR I JAVA
av Anders Andersson
catch(Exception exc){
System.out.println("Hittar ej");
}
ac.play();
}
}
public void nyPosition() {
xpos = xpos + dx;
if (xpos + diam + 20 > 300 || xpos < 0)
dx = -dx;
ypos = ypos + dy;
if (ypos + diam + 37 > 300 || ypos < 0) // y börjar om när det är > 300.
dy = -dy;
}
}
875099958
132
Brogårdsgymnasiet