update

README.md

+# Cheat sheet för TDDC77
+
+[Kommandon](#kommandon) \
+[IDE](#ide-textredigerare) \
+[Git kommandon](#git-kommandon) \
+[Datatyper](#datatyper) \
+[Operatorer](#operatorer-i-java) \
+[Villkorssatser](#villkorssats-conditional-statement) \
+[Loopar](#loopar)\
+[Metoder](#metoder) \
+[Klasser](#klasser)
+
+
+## Terminalen
+
+Välkommen till terminalen!
+För att öppna terminalen på IDA:s datorer kan du använda kortkommandot
+`CTRL+ALT+T` (funkar ej via thinlinc). Sedan kommer en svart ruta med text att
+komma upp. Från denna terminal kan du nu skriva kommandon för att navigera dig
+runt filsystemet.
+
+### Mac
+
+För att enklast öppna en terminal på en Mac söker man efter "Terminal" med
+Spotlight Search. För att få upp Spotlight Search , klicka på `⌘ + Space`.
+
+### Windows
+På Windows öppnar man enklast en terminal genom kortkommandot `Win + R`,
+alltså genom att trycka på Windows-knappen och sedan på R. En liten ruta i
+nedre vänstra hörnet bör dyka upp. Skriv `cmd` i rutan och klicka på OK.
+
+Windows terminal använder inte samma kommandon som Linux och Mac gör. De
+kommandon som vi går igenom kommer alltså inte att fungera på Windows. För att
+kunna köra kommandona under Windows, följ gärna
+[denna](https://www.windowscentral.com/install-windows-subsystem-linux-windows-10)
+tutorial (eller använd Thinlinc).
+
+## Kommandon
+
+**pwd:** Detta kommando visar vart du står i filsystemet.
+
+
+**ls:** Detta kommer att visa alla mappar och filer som ligger i den mappen du
+“står” i. Nu vet du vilka mappar och filer som ligger i denna mapp.
+
+
+**cd:** Detta kommando gör du för att gå till en mapp. Om du t.ex. står i
+`/home/liuID123/` och vill förflytta dig till din TDDC77-mapp så skriver du `cd
+TDDC77`. Du kan sedan testa att skriva `pwd` igen för att säkerställa att du har
+hamnat rätt.
+
+
+**mkdir:** Detta kommando skapar en ny mapp. `mkdir min_mapp` kommer att skapa en
+mapp som heter min_mapp i den katalogen du står i.
+
+
+**rmdir:** Detta kommando tar bort en mapp. Om mappen inte är tom så kommer den
+inte att tas bort. Då kan du använda `rm -r min_mapp`. Detta kommer att ta bort
+mappen oavsett vad som är inuti den. Var försiktig!
+
+
+**cp:** Kommandot `cp` använder du för att göra kopior av filer eller mappar. Skriver du `cp min_mapp `kommer det skapas en ny mapp som heter "min_mapp" i den katalogen du står i.
+
+
+**cat:** Kommandot `cat` kan du använda för att skriva ut en fils innehåll direkt i terminalen. Detta kan vara användbart om du snabbt vill kolla vad en fil innehåller utan att behöva öppna den.
+
+
+**mv:** Kommandot `mv` används för att flytta på en fil eller en mapp. Det
+används även för att byta namn på filer. Antag att vi står i `/home/liuID/`.
+`mv file TDDC77` kommer att flytta filen `file` från hemkatalogen till
+`/home/liuID/TDDC77`.
+
+  * För att byta namn på en fil, flytta den till samma ställe fast med ett
+  annat namn: `mv file newFile` kommer att byta namn på filen `file` till
+  `newFile`.
+
+**grep** Kommandot `grep` används för att hitta rader med ett visst mönster. 
+    Har man en stor fil och vill filtrera den så att bara vissa rader 
+    följer med är `grep` bra att använda.
+
+  * Användning: `grep mönster filnamn`
+    Detta kommer returnera alla raderna i `filnamn` som innehåller 
+    strängen `mönster`. Det går även att använda reguljära uttryck (regex)
+    som mönster. Här är en [länk](https://www.freecodecamp.org/news/grep-command-tutorial-how-to-search-for-a-file-in-linux-and-unix/) 
+    till mer exempel för `grep`.
+
+#### Tips
+
+* **Tab för autokomplettering** - De flesta terminaler idag har stöd för
+autokomplettering av kommandon. Låt oss säga att du står i `/home/liuID/` och
+vill navigera till `/home/liuID/TDDC77/Labbar/`. Istället för att skriva
+`cd TDDC77/Labbar/` manuellt räcker det med att skriva början på mappen
+(fungerar även för filer och kommandon) och att klicka på tab. Skriver du
+`cd TD` följt av tab kommer terminalen att fylla ut med `cd TDDC77/`.
+`cd TDDC77/La` och sedan tab kommer fylla ut raden till `cd TDDC77/Labbar/`.
+
+  Om du glömt vilka filer och mappar som finns i en mapp när du navigerar runt
+finns det en funktion på många system som listar alla filer och mappar där
+man är. Detta gör man genom att klicka på tab en eller två gånger (beroende
+  på system). `cd TDDC77/` följt av tab hade alltså gett samma resultat som
+  att stå i `/home/liuID/TDDC77/` och köra `ls` kommandot.
+
+* **Navigera "uppåt" i filsystemet** - Ofta vill man navigera uppåt, eller
+bakåt ett steg via terminalen. Man kanske vill flytta en fil från
+`/home/liuID/TDDC77/Labbar/` till `/home/LiuID/TDDC77`. Detta gör man enkelt
+genom att skriva `../`. `../` flyttar dig ett steg uppåt i filsystemet.
+Låt oss säga att vi står i `/home/liuID/TDDC77/Labbar/`. `mv file ../` hade
+flyttat filen till `/home/liuID/TDDC77/`. Man kan göra detta för att hoppa upp
+flera steg: `cd ../../` tar dig två steg "uppåt" i filsystemet.
+
+* **Wildcard \*** - Ibland vill man göra något med alla filer/mappar i en
+katalog. Då kan man använda `*`-tecknet. Säg att vi vill flytta alla filer
+i katalogen vi står i ett steg uppåt i filsystemet. Då kan vi skriva
+`mv * ../`.
+
+* **Historik** - Det händer ibland att man skriver ett kommando fel. Man kanske
+råkar skriva ett tecken fel i ett långt kommando. Istället för att skriva
+allting om igen kan man använda piltangenten upp för att gå tillbaka i sin
+historik och hitta kommandot man tidigare skrivit.
+
+  * Ibland vill man se, eller söka bland sina kommandon man tidigare skrivit.
+  Kommandot `history` listar de senaste kommandona man skrivit. Är det för
+  många att gå igenom kan man söka i sin historik genom att klicka på `CTRL+R`
+  och skriva in sitt sökord.
+
+### IDE (textredigerare)
+
+För att skriva kod så behöver man tillgång till en textredigerare eller IDE.
+IDE är en textredigerare som är till främst för att skriva kod i, men det
+fungerar även att skriva kod i notepad eller liknande program. Vi kommer att
+hålla fokus på tre stycken program i denna kursen (`nano`, `atom` och `Eclipse`).
+Ni kommer inte behöva installera några program så länge ni jobbar via skolans
+datorsystem. Det bra att börja med ett simpelt program och jobba sin väg upp,
+så man kan fokusera på programmeringen och inte allt runt omkring.
+
+#### nano
+
+Nano är så simpelt det blir, ni kan starta det på genom att skriva `nano`
+i terminalen. Vill ni skapa en java fil och direkt öppna den i nano skriver ni
+`nano filnamn.java`. För att spara ändringarna som ni gjort i nano så klickar ni
+`CTRL + X` för att avsluta, sedan `y` för att spara och om det är en ny fil
+måste ni även skriva in ett filnamn och klicka `ENTER`.
+
+![Bild på nano](images/nano.png "nano image")
+
+#### Atom
+
+Atom har lite mer inbyggda funktioner och fungerar utmärkt för att hantera lite
+större projekt. Till skillnad från `nano` får ni ett grafiskt gränssnitt som ni
+kan klicka runt i. Ni får även integration med github direkt i atom och snabb
+tillgång till andra filer som finns i samma mapp.
+
+För att starta Atom så skriver ni `atom` i terminalen. Ni kan på samma sätt som i
+nano skapa filer, men här kan ni spara ändrade filer genom `CTLR + S `och
+använda det grafiska gränssnittet för att navigera.
+
+![Bild på atom](images/atom.png "atom image")
+
+#### Eclipse
+
+Eclipse är mycket större än de föregående programmen och kan i början kännas
+lite överväldigande. Det finns dock en del funktioner som är väldigt användbara
+när man programmerar. Eclipse hjälper dig bland annat att hitta fel i koden
+innan du kompilerar den. Du kan genom eclipse även göra något som kallas “debugga”,
+vilket innebär att du kan gå igenom koden steg för steg för att se vad som
+händer (superbra om man stöter på problem som är svårlösta).
+
+För att starta Eclipse i SU-salarna eller på thinlinc, skriv detta kommando i terminalen:
+`/opt/eclipse/4.10/eclipse`
+
+Detta kommer att starta eclipse. Terminalen kommer nu vara kopplad till eclipse
+och stänger ni terminalen kommer eclipse också att stängas. För att göra det 
+lite enklare att starta eclipse kan du skriva in följande i terminalen:
+
+`module add prog/eclipse/4.10`
+
+
+Nu kan ni starta eclipse från terminalen genom att skriva `eclipse` och terminalen 
+går att använda till annat.
+
+En rekommendation är att ändra temat på eclipse så att det blir mer användarvänligt.
+Ni gör det genom att klicka på “Window →  “Preferences” →  “General” → “Appearance”.
+Bilden under är med temat “Dark [Mac OS X]” och font “Classic Theme”.
+
+![Bild på eclipse](images/eclipse.png "eclipse image")
+
+**extra:**
+https://ubuntu.com/tutorials/command-line-for-beginners#3-opening-a-terminal
+
+
+### Git kommandon
+
+* **init** - Startar ett tomt Git-repository eller ominitialiserar ett existerande repo.
+* **clone** - Klonar ett repo till en ny mapp
+* **add** - Lägger till en fil/mapp att följa. Det är dessa filer som indexeras.
+
+ * Tips: `git add --all` lägger till alla ändrade filer till indexet.
+
+* **commit** - Sparar ändringar i repositoriet.
+  * **Användning:** `git commit -m “Updated file”`
+
+* **status** - Visar repositoriets status; vilka filer har ändrats? Vilka ändringar har sparats?
+
+* **pull** - Hämtar och integrerar ändringar från ett repo till ens egna repository
+
+* **push** - Laddar upp ändringarna från ens egna repo till ett annat repository
+
+* **stash** - Gömmer undan lokala ändringar, sparar dem, och återställer ens repo.
+
+* **stash pop** - Laddar tillbaka det man gömde undan när man stashade tidigare.
+
+**extra:**
+https://try.github.io/
+
+## Java
+
+### Kom igång
+
+För att kompilera ett Java program från terminalen använder man `javac`. Man
+skriver helt enkelt `javac MittProgram.java` i terminalen. Efter kompilering går
+det att köra sitt program genom att skriva `java MittProgram` i terminalen.
+
+### Datatyper
+
+* **int** - datatypen int används för att lagra heltal t.ex `int i = 52;`. En int
+är 32 bitar stor och kan lagra värden mellan -2147483648 till 2147483647.
+  - **byte** - 8 bitar stor och lagrar heltal mellan -128 och 127.
+  - **short** - 16 bitar stor och lagrar heltal mellan -32768 och 32767.
+  - **long** 64 bitar stor och lagrar tal mellan -2^63 och 2^63 -1.
+
+* **float** - datatypen float används för att lagra decimaltal t.ex `float f = 3.14;`.
+  En float är 32 bitar stor och är lämplig för tal med 6-7 decimaler.
+  - **double** - 64 bitar stor och är lämplig för tal med 15 decimaler.
+
+* **char** - datatype char används för att lagra ett tecken, t.ex. `char c = 'A';`.
+
+* **String** - datatypen string används för att lagra text t.ex `String s = "jag är en string";`
+
+* **boolean** - datatypen boolean används för att lagra satser och kan endast anta sant eller falsk `boolean b = true;`
+
+### Operatorer i java
+**==** - (Lika med) operator som jämför om högerled är lika med vänsterled, samma som matematikens "="
+
+**!=** - (Inte lika med) operatorn jämför negationen av **==** alltså "inte lika med"
+
+**&&** - (Och) operatorn för den logiska operationen "och", används som i den diskreta matematiken.
+
+**||** - (Eller) operatorn för "eller" operationen, används också som i diskreta matematiken.
+
+**++** - Increment, ökar värdet av en variabel med 1.
+
+**--** - Decrement, minskar värdet av en variabel med 1.
+
+**%** - Modulo, returnerar resten av en division. a%b ger alltså resten för a/b.
+
+
+### Villkorssats (conditional statement)
+#### if-satser
+En if-sats utvärderar en sats och kör koden inom måsvingarna om satsen är är sant.
+
+``` java
+int n = 4;
+int i = 5;
+if(i<3) {
+    System.out.println("i är mindre än 3");
+}
+else if (n<i && n>3) {
+    System.out.println("n är mindre än i och n är större än 3");
+}
+else if (n == 4) {
+    System.out.println("n är lika med 4");
+}
+else {
+    System.out.println("ingen match");
+}
+```
+Programmet ovan kommer att skriva ut:
+
+```
+n är mindre än i och n är större än 3
+```
+
+#### switch case
+En switch kör koden till det case som matchar uttrycket. Varje case måste avslutas med nyckelordet break.
+Default körs endast om uttrycket inte matchar något case.
+
+``` java
+int uttryck = 15;
+switch(uttryck) {
+  case 5:
+    System.out.println("case 5");
+    break;
+  case 10:
+    System.out.println("case 10");
+    break;
+  case 15:
+    System.out.println("case 15");
+    break;
+  case 20:
+    System.out.println("case 20");
+    break;
+  default:
+    System.out.println("default case");
+}
+```
+Programmet ovan kommer att skriva ut:
+
+```
+case 15
+```
+
+### Loopar
+
+#### while loop
+En while loop utvärderar en sats och kör koden inom måsvingarna
+om uttrycket är sant. När koden i måsvingarna körts klart utvärderas satsen
+igen. Om satsen nu är falsk hoppar man ur loopen. Om satsen däremot är sann
+kommer koden inom måsvingarna att köras igen och igen tills att satsen är falsk.
+
+``` java
+int i = 0;
+while (i<5) {
+  i++;
+  System.out.println("loop: " +i);
+}
+System.out.println("klar med loop");
+```
+Programmet ovan kommer att skriva ut:
+
+```
+loop: 1
+loop: 2
+loop: 3
+loop: 4
+loop: 5
+klar med loop
+```
+
+#### do-while loop
+En do-while loop fungerar likt en while loop bortsett från
+att en do while kör koden innan uttrycket utvärderats. Detta garanterar att
+koden i loopen körs minst en gång, även om satsen är falsk.
+
+``` java
+int i = 0;
+do {
+  i++;
+  System.out.println("loop: " +i);
+}
+while (i>10);
+System.out.println("klar med loop");
+```
+Programmet ovan kommer att skriva ut:
+
+```
+loop: 1
+klar med loop
+```
+
+#### for-loop
+När man vill ha mer kontroll över exakt hur många gånger man
+vill loopa igenom en kod kan det vara lämpligt att använda en for-loop. En
+for-loop är uppbyggd på följande vis:
+
+```java
+for (initialisering; villkor; inkrement) {
+  // Kod körs här
+}
+```
+
+Den första delen av for loopen, initialisering, körs endast en gång när loopen
+börjar. Villkoret är ett booleanskt uttryck som avslutar loopen när den är
+falsk. Inkrement är ett uttryck som körs vid varje iteration av loopen. Ett
+typiskt användningsområde för en for-loop kan se ut så här:
+
+```java
+int[] values = { 1,5,2,5,7 };
+int sum = 0;
+
+for (int i = 0; i < values.length; i++) {
+  sum += values[i];
+}
+```
+
+For loopen börjar med att initialisera ett heltal `int i = 0`. Så länge som
+detta heltal är mindre än längden på arrayen `values` kommer loopen att köras.
+Vid varje iteration inkrementeras heltalet `i`. När loopen körts klart kommer
+sum vara lika med 20.
+
+#### for-each-loop
+En enklare variant av for loopen är for-each loopen.
+En for-each loop är ett sätt att traversera genom en array eller en collection.
+Jämför följande kod med exemplet i for-loopen:
+
+```java
+int[] values = { 1,5,2,5,7 };
+int sum = 0;
+
+for (int value : values) {
+  sum += value;
+}
+```
+
+Resultatet blir en mycket mer läsbar kod, speciellt när man börjar blanda in
+lite mer avancerade saker. Låt oss ta exemplet med ett program som har en
+ArrayList av objektet Player:
+`ArrayList<Player> players = new ArrayList<Player>();`
+
+Jämför koden
+```java
+for (int i = 0; i < players.size(); i++) {
+  players.get(i).getName();
+}
+```
+med
+
+```java
+for(Player p : players) {
+  p.getName();
+}
+```
+for-each loopar kommer med ett antal begränsningar. Det går exempelvis inte
+att ändra på element som traverseras. `p = new Player();` hade alltså inte ändrat
+på objektet i `players`, utan `p` är bara en kopia av objektet i arraylistan.
+Loopen håller inte heller reda på index, och det går bara att iterera
+framlänges.
+
+
+### Klasser och metoder
+
+Klasser och metoder är sätt att dela upp och strukturera sin kod.
+
+#### Metoder
+
+En metod är ett block av kod som bara körs när man kallar på den. Metoder kan
+ta emot parametrar, eller inga alls, och returnera data, eller ingen alls.
+Metoder är bra att använda när man behöver använda samma kod på flera ställen.
+Det gör koden mer läsbar och mer effektiv.
+
+Här är ett exempel på hur det går att deklarera en metod;
+
+```java
+public double celsiusToFarenheit(double celsius) {
+  return 1.8 * celsius + 32;
+}
+```
+
+Deklarationen består av flera delar:
+
+* Den första delen är, i vårt fall, `public`, är en modifierare. Med `public` 
+tillåter vi åtkomst till metoden från alla klasser i programmet. Vill vi 
+begränsa åtkomst till metoden så att den bara går att köra från klassen 
+den är definierad i kan vi använda `private` istället. Dessa modiferare 
+fungerar även för variabler i klassen.
+
+* Den andra delen är returtypen, i vårt fall `double`. Denna berättar vad för
+datatyp metoden kommer att returnera. En metod kan returnera vilken
+datatyp som helst och även objekt som man själv skapat. Det finns även
+en speciell datatyp som heter `void`. En metod med returtypen `void` returnerar
+ingenting
+
+* Den tredje delen är namnet, `celsiusToFarenheit`. I Java brukar metoder börja
+med liten bokstav och varje nytt ord börjar med stor bokstav. Precis som med
+variabler är det viktigt att metodnamnen beskriver vad metoden faktiskt gör.
+Detta för att göra koden mer läsbar. Det är med namnet som man faktiskt
+kallar på metoden.
+
+* Den fjärde delen av metoden är parameterlistan (argumenten) inom parenteserna,
+`(double celsius)`. Parametrarna används föra att skicka in data till metoden.
+De går att använda som variabler inom metoden. För att ta emot flera
+parametrar separerar vi dem med ett komma: `(int param1, int param2)`.
+
+* Den femte delen är kroppen - delen innanför måsvingarna. Det är här självaste
+koden för metoden skrivs.
+
+För att kalla på vår metod vi deklarerat och spara returvärdet i variabeln
+`farenheit` skriver vi
+
+```java
+double farenheit = celsiusToFarenheit(25); // farenheit = 77
+```
+
+Låt oss ta ett annat exempel med en metod med returtypen `void`:
+
+```java
+public void sayHello(){
+  System.out.println("Hello there!");
+}
+```
+När vi kallar på `sayHello();` kommer koden inom måsvingarna att köra.
+
+### Klasser
+
+En klass i Java kan man säga är en mall för ett objekt. Klassen beskriver
+ett objekts egenskaper, hur objektet konstrueras och alla dess metoder.
+
+#### Konstruktorn
+
+För att skapa ett objekt ur en klass anropar man på en klass konstruktor.
+Konstruktorn är en metod som används för att skapa ett objekt. Nedan är
+ett exempel på en klass `Car` med en konstruktor.
+
+```java
+public class Car {
+  public Car() {
+  }  
+}
+```
+
+En konstruktor deklareras på samma sätt som en metod, med skillnaden att
+konstruktorn måste ha samma namn som klassen och att den inte har något
+returvärde. Just nu har vår  bil inga egenskaper. Tänk om vi vill skapa
+en bil med en specifik färg? Då kan vi lägga till dess färg som en egenskap
+och tilldela den färgen när objektet skapas:
+
+```java
+public class Car {
+  private String color;
+
+  public Car(String carColor) {
+    color = carColor;
+  }  
+}
+```
+
+För att skapa en ny `Car` med namnet `myCar` kan vi kalla på konstruktorn
+med `new` operatorn:
+
+```java
+Car myCar = new Car("Blue");
+```
+
+Vi kanske bestämmer oss för att ändra på bilens färg efter att den har skapats. Försöker 
+vi göra detta genom att i vårt program skriva 
+
+```java
+Car myCar = new Car("Blue");
+myCar.color = "Red";
+```
+
+kommer vi att få ett error. Vi försöker komma åt bilens egenskap `color` när 
+vi står utanför `Car` klassen. I och med att vi definierade `color` som `private` 
+kan vi inte komma åt den utanför klassen. Istället får vi skriva en metod, en så 
+kallad setter, för att ändra på färgen. En setter är en publik metod som kan ändra 
+på privata egenskaper utanför klassen:
+
+```java
+public class Car {
+  private String color;
+
+  public Car(String carColor) {
+    color = carColor;
+  }  
+
+  // Setter-metod som sätter bilens color till en ny String newColor
+  public void setColor(String newColor) {
+    color = newColor;
+  }
+}
+```
+
+Vi kan nu sätta färgen utanför klassen genom att skriva 
+```java
+Car myCar = new Car("Blue");
+myCar.setColor("Red");
+```
+
+På samma sätt vill vi kanske komma åt bilens färg utanför klassen. Då använder 
+vi oss av en getter; en metod som returnerar en klass egenskap.
+
+```java
+public class Car {
+  private String color;
+
+  public Car(String carColor) {
+    color = carColor;
+  }  
+
+  // Setter-metod som sätter bilens färg till en ny String newColor
+  public void setColor(String newColor) {
+    color = newColor;
+  }
+
+  // Getter-metod som returnerar bilens färg
+  public String getColor() {
+    return color;
+  }
+}
+```
+
+För att göra koden lite mer läsbar kan man använda sig av nyckelordet `this` i 
+sin klass:
+
+```java
+public class Car {
+  private String color;
+
+  public Car(String color) {
+    // Här använder vi this
+    this.color = color;
+  }  
+
+  // Setter-metod som sätter bilens färg till en ny String newColor
+  public void setColor(String color) {
+    // Här med
+    this.color = color;
+  }
+
+  // Getter-metod som returnerar bilens färg
+  public String getColor() {
+    return color;
+  }
+}
+```
+
+Nyckelordet `this` används för att referera till nuvarande objektet - instansen 
+av objektet vars metod eller konstructor kallas på. Det går att komma åt 
+objektets egenskaper inom en metod eller konstruktor genom att använda `this`.
+Det vanligaste användningsområdet för `this` är när ett objekts egenskap 
+"skuggas" av en metod eller konstruktor. Vad som menas med att den "skuggas" 
+är att variabelnamnen i parametrarna har samma namn som de i klassens 
+egenskaper. Som i vårt fall ovan ser vi att i konstruktorn tar man emot 
+en `String color`. Klassen har redan en variabel `String color`. Hur vet 
+man vilken variabel man refererar till? Med `this.color` vet vi att vi 
+refererar till klassens `String color`, inte parameterns `String color`.