Add oving0

.gitignore

@@ -14,11 +14,4 @@ target/
 out/
 
 # JDT-specific (Eclipse Java Development Tools)     
-# .classpath
-
-# Include directories for initial commit
-src/main/resources/*
-!src/main/resources/.gitkeep
-
-src/test/java/*
-!src/test/java/.gitkeep
+# .classpath

oppgavetekster/oving0/README.md

@@ -0,0 +1,66 @@
+# Øving 0: Oppsett av Java
+
+Denne øvingen er valgfri og ikke en del av det tellende øvingsopplegget. Øvingen er ment som en introduksjon til Java og hvordan du kan komme i gang med å programmere i Java. Du skal installere Java Development Kit (JDK) og kjøre enkle Java-programmer. Du skal også lære grunnleggende forskjell på Java og Python, og oversette Python-kode til Java.
+
+## Øvingsmål
+
+- Intallere Java Development kit
+- Installere og sette opp VS Code og Git
+- Lære grunnleggende forskjell på Java og Python, og oversette Python-kode til Java
+- Kjøre og kompilere Java-kode
+- Kjøre enhetstester for å sjekke at koden fungerer som den skal
+
+### Del 1: Installere JDK og VS Code
+
+For å kunne programmere i Java må du installere Java Development Kit (JDK). Vi kommer til å bruke VS Code som koderedigeringsverktøy i TDT4100.
+
+- Gå inn på [denne siden](https://www.ntnu.no/wiki/x/Fgb6DQ) og følg instruksjonene for å installere JDK og VS Code. Husk å følge instruksjonene for ditt operativsystem. **På grunn av trøbbel med tilgang til å redigere wiki er denne litt utdatert. Den anbefaler Java 21, men vi kommer til å bruke Java 23. Dere finner den [her](https://adoptium.net/temurin/releases/?version=23&os=any).**
+
+### Del 2: Sette opp øvingsprosjektet
+
+For å kunne gjøre øvingene i TDT4100 må du sette opp et prosjekt i VS Code. Dette gjør du ved å følge instruksjonene på [denne siden](https://www.ntnu.no/wiki/x/Ggb6DQ). Husk å følge instruksjonene for ditt operativsystem. **På grunn av samme feil som nevnt i forrige del vil også denne siden være litt utdatert. Dere vil ikke klone fra "<https://gitlab.stud.idi.ntnu.no/tdt4100/v2024/tdt4100-students-24>", men fra [https://git.ntnu.no/tdt4100/tdt4100-ovinger-25](https://git.ntnu.no/tdt4100/tdt4100-ovinger-25).**
+
+### Del 3: Hello world
+
+For å teste at du har installert JDK og VS Code riktig, og satt opp prosjektet riktig, skal du nå kjøre et enkelt program som skriver ut "Hello world!" til konsollen.
+
+- Åpne øvingsprosjektet i VS Code. Sørg for at mappen `tdt4100-ovinger-25` er den ytteste mappen i VS Code:
+  ![oppgavetekster/oving0/ovingsprosjekt.png](./img/prosjektmappe.png)
+
+- Åpne filen [src/main/java/oving0/HelloWorld.java](../../src/main/java/oving0/HelloWorld.java).
+  Denne filen inneholder et enkelt program som skriver ut "Hello world!" til konsollen. Klikk på "Run" knappen i VS Code for å kjøre programmet. Du skal nå se "Hello world!" i konsollen:
+  ![oppgavetekster/oving0/helloworld.png](./img/helloWorld.png)
+
+### Del 4: JavaFX og SceneBuilder
+
+#### JavaFX
+
+For å teste at JavaFX er installert riktig, skal du nå kjøre et enkelt program som bruker JavaFX. Åpne filen [src/main/java/oving0/todolist/fxui/TodoApp.java](../../src/main/java/oving0/todolist/fxui/TodoApp.java). Klikk på "Run" knappen i VS Code for å kjøre programmet. Du skal nå se en todolist applikasjon. Hvis du får en feilmelding i VS Code, prøv å trykke ctrl/cmd+shift+p og skriv "Java: Clean the Java language server workspace" og trykk enter. Hvis du fortsatt får feilmelding, prøv å lukke VS Code og åpne det på nytt.
+
+#### SceneBuilder
+
+Følg instruksjonene på [denne siden](https://www.ntnu.no/wiki/x/LAMxDg) for å installere SceneBuilder. Scene Builder er et verktøy som kan brukes til å designe brukergrensesnitt for JavaFX-applikasjoner. SceneBuilder er ikke nødvendig for å gjøre øvingene, men det vil være nyttig i prosjektet.
+
+For å teste at SceneBuilder er installert riktig, skal du nå åpne todolist-applikasjonen i Scene Builder. Åpne SceneBuilder programmet, og klikk "Open Project". Naviger frem til filen [src/main/resources/oving0/todolist/fxui/Todo.fxml](../../src/main/resources/oving0/todolist/fxui/Todo.fxml) og velg den. Du skal nå se todolist-applikasjonen i Scene Builder:
+
+![oppgavetekster/oving0/scenebuilder.png](./img/scenebuilder.png)
+
+### Del 5: Kjøre enhetstester
+
+Enhetstester er en måte å sjekke at koden fungerer som den skal. I øvingene i TDT4100 følger det med enhetstester for hver oppgave. For å sjekke at prosjetet ditt er satt opp riktig, skal du kjøre enhetstester for Hello world-programmet.
+
+- Åpne filen [/src/test/java/oving0/HelloWorldTest.java](../../src/test/java/oving0/HelloWorldTest.java). Denne filen inneholder enhetstester for Hello world-programmet. For å kjøre alle testene klikker man på den øverste grønne dobbel-pilen i VS Code. Man kan også kjøre en og en test ved å klikke på den grønne enkelt-pilen ved siden av hver test:
+  ![oppgavetekster/oving0/test.png](./img/kjor_test.png)
+
+- Etter å ha kjørt testene skal du se at alle testene er grønne, og at det står 2/2 tests passed i vinduet som åpner seg til venstre:
+  ![oppgavetekster/oving0/test_resultat.png](./img/Passed_tests.png)
+
+### Del 6: Java vs Python
+
+I denne delen skal du lære grunnleggende forskjell på Java og Python, og oversette Python-kode til Java. Fortsett i [denne filen](./python_vs_java.md).
+
+### Del 7: Videre lesing
+
+Har du kommet til denne delen er du nok klar for å starte på de ordentlige øvingene. Vi anbefaler også at du blir litt kjent med Wiki-sidene, spesielt [Objektorientert programmering](https://www.ntnu.no/wiki/x/wRzuAw), [Java programmering](https://www.ntnu.no/wiki/x/zx3uAw) og [Prosedyreorientert programmering](https://www.ntnu.no/wiki/x/qx3uAw). Det er ikke forventet at dere skal lese alt som står på alle undersidene her, men det er greit å ha en oversikt over hva som er der, så vet dere hvor dere kan finne informasjon om dere trenger det.
+
+Lykke til med øvingene!

oppgavetekster/oving0/python_vs_java.md

@@ -0,0 +1,259 @@
+# Python VS Java
+
+Noe av det første du kommer til å merke når du skal programmere i Java er at det kreves en del flere linjer kode enn i Python. La oss starte med noe av det enkleste, å skrive ut en tekst til konsollen.
+
+## Skrive ut tekst til konsollen
+
+I Python er det veldig greit å skrive ut tekst til konsollen. Du trenger bare å skrive `print("tekst")` og så vil teksten skrives ut til konsollen. I Java trengs det litt bokstaver:
+
+**Python**:
+
+```python
+print("Hello World!")
+```
+
+**Java**:
+
+```java
+System.out.println("Hello World!");
+```
+
+En snarvei i VS Code for å slippe å skrive hele `System.out.println()` er å skrive `sout` og trykke `tab`-tasten. Da vil hele koden bli skrevet ut for deg.
+
+## Variabler
+
+I Python er det ganske rett frem å lage variabler. Du trenger bare å skrive `variabelnavn = verdi`. I Java må du først angi hvilken type variabelen skal være. De vanligste typene er `int`, `double`, `boolean` og `String`. `double` er et desimaltall (samme som `float` i python), `boolean` er en `true` eller `false`-verdi og `String` er en tekststreng.
+
+La oss se på et eksempel:
+
+**Python**:
+
+```python
+x = 5
+y = 10.6
+s = "hei"
+ja = True
+```
+
+**Java**:
+
+```java
+int x = 5;
+double y = 10.6;
+String s = "hei";
+boolean ja = true;
+```
+
+Noen ting som er viktig å merke seg:
+
+- I Java må man ha semikolon på slutten av hver linje der man deklarerer variabler (og mange andre steder, men det kommer vi tilbake til senere).
+
+- Boolske verdier skrives med liten forbokstav i Java (`true`, `false`), mens de skrives med stor forbokstav i Python.
+
+## Oppgave 1
+
+Nå skal du lage et program som ganger sammen to tall og skriver ut resultatet til konsollen. Bruk variabler til å lagre tallene. Bruk `System.out.println()` til å skrive ut resultatet.
+
+- Lag en ny fil ved å høyreklikke på `src/main/java/oving0`-mappen og velg `New file...`. Gi filen et navn som slutter på `.java`, for eksempel `Oppgave1.java`. Når du trykker Enter vil du få opp den nye filen og noe forhåndsutfylt kode:
+  ![Ny fil](./img/opp1.png)
+  Velg `class`.
+
+- For å kjøre kode i Java må man lage en `main`-metode. Denne ser slik ut:
+
+```java
+public static void main(String[] args) {
+    // Kode her
+}
+```
+
+- Enten kopier koden over, eller skriv `main` og trykk `tab`-tasten for å auto-fylle koden.
+
+- Lag to variabler som inneholder tallene du skal gange sammen. Du kan kalle dem `x` og `y` eller noe annet du vil. Velg selv om du vil bruke `int` eller `double`.
+
+- Lag en variabel som inneholder resultatet av gangeoperasjonen. Du kan kalle den `z` eller noe annet du vil.
+
+- Skriv ut resultatet til konsollen ved å bruke `System.out.println();`.
+
+## `if`-setninger
+
+Nå skal vi se på forskjellen mellom `if`-setninger i Python og Java:
+
+**Python**:
+
+```python
+if betingelse1 or not betingelse2:
+    # Kode her
+elif betingelse1 and betingelse2:
+    # Kode her
+else:
+    # Kode her
+```
+
+**Java**:
+
+```java
+if (betingelse1 || !betingelse2) {
+    // Kode her
+}
+else if (betingelse1 && betingelse2) {
+    // Kode her
+}
+else {
+    // Kode her
+}
+```
+
+Viktige forskjeller å merke seg:
+
+- Python bruker kolon (`:`) etter if-setningen, mens Java bruker krøllparenteser (`{}`).
+
+- Python bruker `elif` for å si at det er en `else if`-setning, mens Java bruker `else if`.
+
+- Python bruker innrykk for å si at noe kode skal være inni if-setningen, mens Java bruker krøllparenteser.
+
+- Python bruker `and` og `or`, mens Java bruker `&&` og `||` for å si at to betingelser skal være sant samtidig eller at en av betingelsene skal være sant.
+
+- Python bruker `not` for å si at en betingelse skal være falsk, mens Java bruker `!`.
+
+- Java krever at betingelsene er omgitt av parenteser.
+
+## Oppgave 2
+
+Velg om du vil lage en ny fil eller bruke den du lagde i forrige oppgave. Skriv koden i en `main`-metode.
+Oversett koden under fra Python til Java:
+
+```python
+x = 3
+y = 5
+
+if x > 5 and y < 10:
+    print("x er større enn 5 og y er mindre enn 10")
+elif x > 5 or y < 10:
+    print("x er større enn 5 eller y er mindre enn 10")
+else:
+    print("x er mindre enn 5 og y er større enn 10")
+```
+
+## Løkker
+
+Nå skal vi se på forskjellen mellom løkker i Python og Java:
+
+**Python**:
+
+```python
+for i in range(10):
+    # Kode her
+
+while betingelse:
+    # Kode her
+```
+
+**Java**:
+
+```java
+for (int i = 0; i < 10; i++) {
+    // Kode her
+}
+
+while (betingelse) {
+    // Kode her
+}
+```
+
+`while`-løkken er ganske lik i Python og Java. `for`-løkken kan virke litt mer skremmende, men vi skal se på den litt nærmere.
+
+### For-løkker
+
+En `for`-løkke i Java består av tre deler, og ligner egentlig ganske mye på en `while`-løkke. De tre delene er:
+
+- En variabel som skal telle oppover eller nedover. Denne kan være av typen `int`, `double` eller `float`. Denne variabelen må være unik for løkken, det vil si at den ikke kan hete det samme som en variabel som allerede er brukt i koden.
+
+- En betingelse som må være sant for at løkken skal fortsette.
+
+- En operasjon som skal utføres hver gang løkken kjører. Denne operasjonen kan være å øke eller redusere variabelen som telle oppover eller nedover.
+
+I eksempelet over er variabelen `i`, betingelsen `i < 10` og operasjonen `i++`. Variabelen, betingelsen og operasjonen er sepparert med semikolon (`;`). `i++` betyr at variabelen `i` skal økes med 1 hver gang løkken kjører. Man kan også øke med for eksempel `3`, og skrive `i += 3`. Startverdien til variabelen kan endres til f.eks. `5` ved å skrive `for (int i = 5; ...`.
+
+## Oppgave 3
+
+Velg om du vil lage en ny fil eller bruke den du lagde i forrige oppgave. Skriv koden i en `main`-metode.
+
+Oversett koden under fra Python til Java:
+
+```python
+for i in range(3,10):
+    if i % 2 == 0:
+        print(i)
+
+j = 0
+while j < 10:
+    print(j)
+    j += 1
+```
+
+## Funksjoner
+
+Nå skal vi se på forskjellen mellom funksjoner i Python og Java:
+
+**Python**:
+
+```python
+def funksjonsnavn(parameter1, parameter2):
+    # Kode her
+    return resultat
+```
+
+**Java**:
+
+```java
+public int funksjonsnavn(int parameter1, int parameter2) {
+    // Kode her
+    return resultat;
+}
+```
+
+De fleste funskjoner man lager i Java hører til en gitt **klasse** (ikke tenk på hva dette er akkurat nå, dette lærer dere snart). Funksjoner som hører til klasser kalles **metoder**.
+
+En metode i Java har alltid en **return-type**. Return-type er typen variabelen som skal returneres fra metoden. Return-type kan være `void`, `int`, `double`, `float`, `String` eller en annen type. Hvis return-type er `void` betyr det at metoden ikke skal returnere noe. Alle parametre som skal sendes til metoden må ha en **type**. Typen til parametrene kan være `int`, `double`, `float`, `String` eller en annen type. For nå kan du ignorere at det står `public` foran metoden, dette lærer du om snart.
+
+Alle funskjoner (metoder) i Java må ligge inni en klasse.
+
+Eksempel på en klasse med en metode:
+
+```java
+package minpakke;
+
+public class KlasseNavn {
+
+    // Kode her
+
+    public int metode1(int parameter1, int parameter2) {
+        // Kode her
+        int resultat = parameter1 + parameter2;
+        return resultat;
+    }
+}
+```
+
+## Oppgave 4
+
+Enten lag en ny klasse, eller bruk den du brukte i forrige oppgave. Lag metoder som tilsvarer funksjonene i Python-koden under:
+
+```python
+def division(x, y):
+    return x / y
+
+def fakultet(x):
+    fak = 1
+    for i in range(1, x+1):
+        fak *= i
+    return fak
+
+def erPrimtall(x):
+    if x < 2:
+        return False
+    for i in range(2, x):
+        if x % i == 0:
+            return False
+    return True
+```

src/main/java/oving0/HelloWorld.java

@@ -0,0 +1,16 @@
+package oving0;
+
+public class HelloWorld {
+
+    public String getHelloWorld() {
+        return "Hello World!";
+    }
+
+    public int getHelloWorldLength() {
+        return this.getHelloWorld().length();
+    }
+
+    public static void main(String[] args) {
+        System.out.println(new HelloWorld().getHelloWorld());
+    }
+}