Installera konfigurationsfiler med följande kommando:

   /home/TDDD78/bin/installidea.sh

IDEA startas sedan med följande kommando:

   /home/TDDD78/bin/idea15.sh

IDEA kräver en licens som delas ut av en licensserver. När du startar första gången får du därför upp en dialog med namnet "IntelliJ IDEA License Activation". Gör så här:

• Välj Activate your license with: License server.

• Gå till License server address och skriv/klistra in http://appserv.ida.liu.se:4900/

• Tryck OK

Om du får en dialogruta med namnet "Platform and Plugin Updates" väljer du "Ignore This Update".

Det kan hända att du får en del varningar vid starten. Följande varningar kan du strunta i:

Note: Storing IDEA's temporary files on the local disk (good!)
[YourKit Java Profiler 2014 build 14112] Log file: /home/.../.yjp/log/IntelliJIdea15-33899.log
/sw/intelliJ-15.0.3-EAP/bin/idea.properties: 'idea.max.intellisense.filesize' already defined
/sw/intelliJ-15.0.3-EAP/bin/idea.properties: 'idea.cycle.buffer.size' already defined
/sw/intelliJ-15.0.3-EAP/bin/idea.properties: 'idea.no.launcher' already defined
/sw/intelliJ-15.0.3-EAP/bin/idea.properties: 'idea.dynamic.classpath' already defined
/sw/intelliJ-15.0.3-EAP/bin/idea.properties: 'idea.popup.weight' already defined
/sw/intelliJ-15.0.3-EAP/bin/idea.properties: 'idea.use.default.antialiasing.in.editor' already defined
/sw/intelliJ-15.0.3-EAP/bin/idea.properties: 'sun.java2d.noddraw' already defined
/sw/intelliJ-15.0.3-EAP/bin/idea.properties: 'sun.java2d.d3d' already defined
/sw/intelliJ-15.0.3-EAP/bin/idea.properties: 'swing.bufferPerWindow' already defined
/sw/intelliJ-15.0.3-EAP/bin/idea.properties: 'sun.java2d.pmoffscreen' already defined
/sw/intelliJ-15.0.3-EAP/bin/idea.properties: 'idea.xdebug.key' already defined
/sw/intelliJ-15.0.3-EAP/bin/idea.properties: 'idea.fatal.error.notification' already defined
log4j:WARN No appenders could be found for logger (io.netty.util.internal.logging.InternalLoggerFactory).
log4j:WARN Please initialize the log4j system properly.
log4j:WARN See http://logging.apache.org/log4j/1.2/faq.html#noconfig for more info.

Skapa ett paket genom att högerklicka på src som ligger under modulen lab1 i projektbrowserns hierarki. Att 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 skriver bara in 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 in koden för ett litet Hello World-exempel 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. Det samma gäller System.out.println(); som kan fås via sout och Ctrl-J.

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ört programmet sparas en körkonfiguration. Man kan välja bland körkonfigurationer och köra dem enkelt via knappmenyn. Om det inte syns en knappmeny i IDEA kan denna tas fram genom View | Toolbar.

Skapa klassen Exercise2 i det paket ni skapade. 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. Därefter skall programmet anropa sumFor(min,max) och skriva ut resultatet med hjälp av anropet System.out.println();. Här lägger ni det som skall skrivas ut mellan parenteserna i funktionsanropet.

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 övningen.

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. Förklaringar till "final" och "static" kommer under föreläsningarna.

Konstruera en loop som skriver ut 5:ans multiplikationstabell.

Testkör sedan programmet på samma sätt som i tidigare övning.

Utöka programmet från förra övningen 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.

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.

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.

Vi avslutar genom att lägga till inmatning även i övning 2 så att talen min och max som används i looparna läses in från användaren.

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. Din uppgift är att se till att den blir körbar och skriver ut 0-fakultet till och med 10-fakultet.

Skapa en ny klass Exercise5 precis som tidigare.

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
        ...
    } 

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() istället skriver ut isPrime(4). Det blir också true vilket ju är fel. Vi har alltså upptäckt ett fel i programmet.

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 samt att raden blir rödmarkerad.

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

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 %. Ändra detta och testkör för att se att 4 inte längre klassas som ett primtal.

Avsluta debuggningen genom att trcka på den röda stoppknappen till vänster eller genom att trycka Ctrl-F2. Notera att debug-fönstret under koden stannar kvar. Ni kan antingen stänga det eller växla tillbaka till run-fönstret.

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

Om ni inte upptäckt det ännu så finns det 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 övning 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 blir 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?

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 number skall funktionen först sätta variabeln x till detta värde och sedan utföra x = x - (x*x-number)/(2*x); 10 gånger innan den returnerar det slutliga värdet på x. (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

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

   Skriv sedan ut resultatet med

   System.out.println("Roten ur "+input+"är "+findRoot(input));  

4. Vad händer när ni matar in koden? Går det att skicka input till findRoot? Hur kan IDEA veta att det inte går innan koden kompilerats?
5. Fixa koden genom att konvertera input till en double med hjälp av Double.parseDouble.

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 övning 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 "+input+"ä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 input, vilket kanske verkar underligt eftersom input är en sträng – men man hade kunnat använda till exempel input.length(), vilket börjar med input.

Men nu vet du kanske att du vill använda oss 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 det inte innebär något problem för Java att automatiskt förstå att vi vill göra ett flyttal av vårt heltal. 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 talområdet 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;

4. Skriv ut tal, decimaltal och tillbaka och jämför vilka värden som skrivs ut. Ändra nu 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 med System.out.println. Blev det som ni tänkt? Byt datatyp på bigger till en större, long, och jämför. Vad hände?

7. Testa först 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.