Skapa ett paket genom att högerklicka på src som ligger under modulen lab1 i projektbrowserns hierarki. Att ikonen för src är blå indikerar att den är en källkodsmapp. Välj därefter New | Package och skapa paketet se.liu.ida.dinadress.tddd78.lab1.

Skapa sedan klassen Exercise1 genom att högerklicka på paketet (lab1) och välja New | Java Class för att skapa klassen. Du anger bara Exercise1, men det fulla namnet för klassen inklusive paket blir se.liu.ida.dinadress.tddd78.lab1.Exercise1. Klassen skapas med attributet public vilket betyder att kod i alla klasser kan komma åt den. Mer info om åtkomsträttigheter kommer under föreläsningarna.

Skriv ett litet Hello World-program enligt bilden nedan.

Man kan med fördel använda IDEAs Live Template-funktion genom att ställa markören i klassen (inom måsvingarna), välja Code | Insert Live Template: Ctrl-J , och sedan välja main() method declaration. Ett ännu snabbare alternativ är att skriva psvm och trycka Ctrl-J eller Tab. Det samma gäller System.out.println(); som kan fås via sout.

Som synes fick "Exercise1" nu en annan färg, eftersom vissa varningar försvann (klassen är inte tom och den kan användas genom att main() anropas) medan andra tillkom. I labb 1 kan ni ignorera de flesta varningarna eftersom de gäller sådant vi ännu inte har diskuterat.

Högerklicka någonstans i den öppna filen och välj Run Exercise1.main(). Detta kompilerar automatiskt alla okompilerade filer, verifierar att inga kompileringsfel uppstod, och startar det program vi högerklickade. Du bör se utskriften i IDEAs körfönster:

Då man kör programmet skapar IDEA en körkonfiguration. Man kan välja bland körkonfigurationer och köra dem enkelt via knappmenyn (toolbar), och editera dem för att t.ex. lägga till kommandoradsparametrar. Om det inte syns en knappmeny i IDEA kan denna tas fram genom View | Toolbar.

I labb 1 skapar vi oftast en ny klass för varje uppgift. Här skapar du klassen Exercise2 i det paket du skapade tidigare. Klassen kan skapas:

• (a) på samma sätt som förut genom att högerklicka på paketet (lab1) och välja New | Java Class, eller
• (b) genom att ställa markören på klassnamnet Exercise1, trycka F5 (clone) och svara på frågorna.

I det senare fallet behöver man också ta bort onödig kod i den nya klassen – eller kommentera bort den, om man tror att den snart ska användas igen. IDEA underlättar att kommentera bort kodavsnitt genom att man markerar dem och trycker CTRL-/.

1. Skriv en funktion sumFor(int min, int max) som beräknar och returnerar summan av talen min,min+1,...,max med hjälp av en for-loop.

2. Skapa en main()-funktion.

   Vi vill vänta lite till med att titta på hur man hämtar input från användaren. Vi börjar därför med att hårdkoda värden på min och max. Vi kommer senare att läsa in dessa från användaren. Definiera därför int min = 10; och sätt på liknande sätt max till 20 (inuti main). Därefter skall programmet anropa sumFor(min,max) och skriva ut resultatet med hjälp av System.out.println(), ungefär som i exemplet ovan.

3. Testkör!

Eftersom konstruktionerna är så lika testar vi bara en av dem.

1. Skapa nu funktionen sumWhile(...), som har samma parametrar och returvärden som sumFor() men istället använder en while-loop för att beräkna samma summa.

2. Ändra main() så den även anropar sumWhile() och skriver ut resultatet från båda anropen. Testkör programmet. Får du alltid samma summor?

Börja med att skapa klassen Exercise3 för uppgiften.

Deklarera en konstant som anger vilken multiplikationstabell vi skall skriva ut. Denna skall vara synlig endast i klassen och bör deklareras som följer, på toppnivå i klassen:

private final static int TABELL = 5;

Här stöter vi på Javas namngivningsstandard som säger att namn på denna typ av konstanter skall skrivas med stora bokstäver. Att "variabeln" är final gör att dess värde inte kan ändras, så att den faktiskt blir en konstant. Att den är static gör att den bara lagras en gång i klassen, istället för i varje objekt av typ Exercise3 (om vi nu hade skapat några sådana objekt). Djupare förklaringar av detta kommer under föreläsningarna.

1. Konstruera en loop som skriver ut den valda multiplikationstabellen: 1*TABELL, 2*TABELL, osv. upp till 12*TABELL.

2. Testkör programmet på samma sätt som i tidigare uppgift.

1. Utöka programmet från förra uppgiften för att läsa in ett värde från användaren. Detta måste göras i mainmetoden, innan loopen. Exempel:

      String input =
         JOptionPane.showInputDialog("Please input a value"); 

   IDEA kommer att markera att den inte känner till klassen JOptionPane. Vi måste berätta var denna finns genom att antingen trycka Alt + Enter när IDEA föreslår detta, t.ex. då markören står framför raden, eller genom att trycka på den röda glödlampan som dyker upp efter en stund till vänster på raden och välja Import Class.

2. Värdet som läses in är en sträng, och måste konverteras till ett heltal (om möjligt). Exempel:

      int tabell = Integer.parseInt(input); 

   Då detta är en lokal variabel namnges den inte med stor bokstav. Ändra därför från TABELL till tabell i den tidigare utskriften så att det nya värdet används.

3. Provkör!

   Testa gärna att mata in en icke-numerisk sträng och se vad som händer. Vi lämnar som överkurs (frivilligt) att ta hand om felet som uppstår och låta användaren försöka på nytt.

1. Börja med att precis som ovan skapa klassen Exercise4. I den, inuti klassdefinitionen (mellan måsvingarna {}), klistrar du in följande felaktiga kod:

   public static void main(String[] args) {
     for (int i = 0; i < 10; i+1) {
       system.out.println(i + "-fakultet: " + facrotial(i));
     }
   }
   
   /**
   * Calculates f! given f.
   * @param f
   * @return f!
   */
   private factorial(int f) {
     if (f = 0)
       return 1;
     }
   
     int result = 1
     for (int i = 1; i <= f; i+1) {
       result *= i;
     }
   
     return result
   }
   

   IDEA kommer helt utan att kompilera koden att känna av och markera en hel del fel. Det finns ett 10-tal fel varav ett är att "static"-kod i detta fall endast kan anropa annan "static"-kod.

2. Se till att koden blir körbar och skriver ut 0-fakultet till och med 10-fakultet.
3. Testa att skriva ut n-fakultet för större värden på n. Hur långt kan man komma? Var börjar det bli fel? Varför? (Om du inte vet svaret kommer vi att titta på det senare.)

1. Skapa en ny klass Exercise5 precis som tidigare.

2. Skapa en egen metod, public static boolean isPrime(int number), vars ansvar är att testa om number är ett primtal.

   I metoden lägger vi en for-loop som går igenom alla tal 2,3,..., inparameter-1 och ser om någon delar talet. I så fall returneras false, annars true. Här behövs alltså en if-sats inuti for-loopen.

   För att avgöra om ett tal delar inparametern använder vi följande felaktiga kod:

       int rest = number / i;
       if (rest == 0) {
           // number är en jämn multipel av i
           ...
       } 

3. Vi testkör nu funktionen. Låt main() skriva ut resultatet av isPrime(5). Starta klassen som vanligt. Svaret bör bli true om du har gjort rätt.

   Modifiera programmet så att main() även skriver ut isPrime(4). Det blir också true vilket ju är fel. Vi har alltså upptäckt ett fel i programmet.

1. Sätt en brytpunkt på raden if (rest == 0) genom att vänsterklicka i listen till vänster om koden eller genom att stå på raden och trycka CTRL-F8. En brytpunkt indikeras genom en röd cirkel i listen till vänster samt genom att raden blir färgmarkerad.

2. Starta programmet i debuggern genom att högerklicka och välja Debug Exercise5.main() (inte "Run"!). Det ger följande fönster:

   

   Programmet har nu startats, men har automatiskt pausats då brytpunken nåtts. Detta visas genom att raden med brytpunkten får blå färg.

   Notera att debug-fönstret visas under kodfönstret. I debug-fönstret finns som standard tre mindre fönster. Det vänstra visar vilken anropskedja som ledde oss till funktionen vi befinner oss i körs – i det här fallet anropades den från main(). Det mittersta visar intressanta variabler och deras värden. Det högra visar Watches som är variabler vi valt att hålla extra koll på (för närvarande inga).

3. Nu är det dags att se vad som har hänt.

   I debuggern ser vi att vi att number=4 och i=2. Vi ser i koden att vi försökte hitta resten vid division med i, och i debuggern att resten faktiskt blev 2, vilket inte är vad vi förväntat oss. 4 är ju jämnt delbart med 2!

   Alltså måste något vara fel på den tidigare raden och mycket riktigt, / borde ju vara en annan operator. Vilken? Ändra detta och testkör (starta om debuggern) för att se att 4 inte längre klassas som ett primtal.

4. När allt fungerar kan du avsluta debuggningen genom att trycka på den röda stoppknappen till vänster eller genom att trycka Ctrl-F2. Notera att debug-fönstret under koden stannar kvar. Du kan antingen stänga det eller växla tillbaka till run-fönstret.

Vi avslutar den här uppgiften genom att skriva ut alla primtal under 100.

Gör en for-loop i main() metoden. Iterera över talen från 2 till 100 och skriv ut alla som klassificeras som primtal.

Det finns en fori-mall för att snabbt få till en for-loop. Använd den på samma sätt som psvm och sout.

1. Vi skall utöka koden i uppgift 1.2. Låt main() använda JOptionPane.showInputDialog för att läsa in en textsträng som skall vara "for" eller "while".

   Låt switch-satsen anropa rätt summeringsfunktion beroende på denna input. Glöm inte break!

   Lägg även till en default-etikett i switch-satsen. Denna gren utförs om man inte skrev in något av de acceptabla valen och bör alltså skriva ut ett felmeddelande.

2. Testa programmet!

1. Skapa en ny klass, Exercise8, med en tom main-metod. Skriv sedan funktionen askUser som tar som inparameter en sträng som kommer att presenteras för användaren av programmet. Funktionen skall returnera sant om användaren svarar "ja", vilket åstadkoms genom att returnera det booleska värdet av följande uttryck:

   JOptionPane.showConfirmDialog(null, question, "",
     JOptionPane.YES_NO_OPTION) == JOptionPane.YES_OPTION
             

2. Lägg till kod i main-metoden så att programmet ligger i en evig loop med hjälp t.ex. av en while(true)-loop.

   Nu skall man få möjligheten att avbryta, men bara om man är helt säker. Detta görs genom att ställa frågorna askUser("Quit?") och askUser("Really ?"). Om båda svaren från askUser blir true skall programmet avslutas (return från main-metoden) och annars ska det skriva ut att programmet fortsätter köra.

   Prova båda varianter nedan (en i taget!) och ge olika svar på frågorna:

   if (askUser("Quit?") && askUser("Really?")) { ... }
   if (askUser("Quit?") & askUser("Really?")) { ... }

   Vilken verkar bäst att använda i detta fall? Vad händer med respektive utan kortslutning?

Vi skall återanvända ett exempel från Python-kursen, implementationen av Newton-Raphsons klassiska metod, i det här fallet hårdkodad för att hitta kvadratroten ur ett tal.

1. Skapa en ny klass, Exercise9, med en tom main-metod. Skriv sedan funktionen findRoot som tar som inparameter en double (vi vill ju räkna med decimaler) och returnerar en double.
2. Givet att inparametern heter x skall funktionen först sätta variabeln guess till detta värde och sedan utföra guess = guess - (guess*guess-x) / (2*guess); 10 gånger innan den returnerar det slutliga värdet på guess. (Mer information om metoden finns här: Newton-Raphson.)
3. Lägg till inläsning av det värde vi vill hitta roten ur i main-metoden. Inläsning sker med hjälp av JOptionPane på samma sätt som tidigare:

   String x =
       JOptionPane.showInputDialog("Please input a value"); 

   Vad händer när du matar in koden? Går det att använda x som argument till findRoot? Hur kan IDEA annars veta att det inte går innan koden körs?

4. Fixa koden genom att konvertera inmatningen till en double med hjälp av Double.parseDouble.

5. Se till att koden skriver ut resultatet, och testkör!

Det här är ett bra tillfälle att illustrera hur IDEAs funktion för komplettering blir mer kraftfull med hjälp av variabeltyper.

Testa i koden för uppgift 1.9 att ta bort parametern som skickas till findRoot, och ställ sedan markören i den tomma parentesen precis som om du höll på att skriva den här koden just nu:

System.out.println("Roten ur " + x + " är " + findRoot([markör]));

När du trycker Ctrl-space (basic code completion) föreslår IDEA allt som skulle kunna stå i den här positionen. Bläddra gärna i listan och se vad som är möjligt att skriva här. Ett exempel är x, vilket kanske verkar underligt eftersom x är en sträng – men man hade kunnat använda till exempel x.length(), vilket börjar med x.

Men nu vet du kanske att du vill använda dig av en variabel som redan är av rätt typ. Då trycker du Ctrl-shift-space (type completion). IDEA föreslår då endast att man kompletterar med något som direkt matchar typen på den valda positionen. I detta fall minskas möjligheterna avsevärt. Du kan läsa mer här: auto completion.

1. Skapa en ny klass, Exercise10, med en tom main-metod. Vi skall nu lägga till kod till main-metoden.

2. Börja med att lägga till int tal = 16777216;. Vi skall nu konvertera denna till en float och sedan tillbaka till int för att se vad som händer. Lägg därför till float decimaltal = tal;. Lägg märke till att eftersom det talområde som kan representeras av en float är större än motsvarande för en int accepteras detta av Java. Det sker en implicit typkonvertering, dvs vi behöver inte skriva något extra.

3. Konvertera nu tillbaka genom att lägga till int tillbaka = decimaltal;. Vad händer?

   I det här fallet kan inte decimalerna för en float rymmas i en int och Java kräver att man hanterar detta, t.ex. genom att göra en explicit typkonvertering (avrundning) genom att skriva int tillbaka = (int)decimaltal;. Då visar man att man verkligen ville bli av med decimalerna.

4. Skriv ut tal, decimaltal och tillbaka och jämför vilka värden som skrivs ut. Ändra sedan från 16777216 till 16777217 och jämför utskrifterna. Vad händer?

5. Byt typ på decimaltal till double och jämför resultatet. Vad händer?

6. Lägg till nya variabler int big = 2147483647; samt int bigger = big+1. Gissa först vad som kommer att skrivas ut och skriv sedan ut värdena. Blev det som ni tänkt? Byt datatyp på bigger till en större, long, och jämför. Vad hände?

7. Testa att ändra biggers definition till long bigger = big+1L; och notera resultatet. Slutligen ändrar vi till long bigger = (long)big+1; och jämför.

1. Läs gärna på lite om Tetris. Det kan hjälpa dig i resten av labbserien.

2. Om du inte har spelat Tetris tidigare: Testa någon gratisvariant, t.ex. M-x tetris RET i vissa varianter av Emacs. Uppgifterna kommer att förutsätta att du vet hur Tetris fungerar.

1. Skapa ett paket för Tetris, med lämpligt namn -- t.ex. se.liu.ida.dinadress.tddd78.tetris.

   Paketnamnet måste innehålla "tetris" någonstans! Namnet kommer att användas av mjukvara som automatiskt separerar Tetris-kod från annan kod vid inlämning.

1. Skapa en enum-typ genom att högerklicka på Tetris-paketet i IDEA, välja New | Java Class och sätta "Kind" till Enum. Ge klassen namnet SquareType.

2. Lägg in följande inom klamrarna:
   EMPTY, I, O, T, S, Z, J, L

   Klassen ser alltså ut så här:

   public enum SquareType
   {
       EMPTY, I, O, T, S, Z, J, L
   }
   	  

   Detta betyder helt enkelt att typen SquareType har värdena SquareType.EMPTY, SquareType.I, SquareType.O, och så vidare. Eventuellt klagar IDEA på att namnen är för korta. Detta kan du ignorera.

   Här finns mer information om enum-typer om du skulle vara nyfiken på mera detaljer.