Add oving 1

README.md

@@ -5,3 +5,4 @@ Denne mappen inneholder øvingstekster for TDT4100 - Objektorientert programmeri
 | Øving                                        | Tema                                      |
 | -------------------------------------------- | ----------------------------------------- |
 | [Øving 0](./oppgavetekster/oving0/README.md) | Introduksjon og oppsett av Java           |
+| [Øving 1](./oppgavetekster/oving1/README.md) | Java-syntaks og objektorientert tankegang |

oppgavetekster/oving0/README.md

@@ -18,7 +18,7 @@ For å kunne programmere i Java må du installere Java Development Kit (JDK). Vi
 
 ### 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).**
+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-26](https://git.ntnu.no/tdt4100/tdt4100_ovinger-26).**
 
 ### Del 3: Hello world
 

oppgavetekster/oving1/Account.md

@@ -0,0 +1,24 @@
+# Tilstand og oppførsel – Account
+
+Oppgaven handler om en `Account`-klasse, som håndterer data i en bankkonto. Tilstanden i `Account`-objekter er som følger:
+
+- `balance` - et desimaltall som angir beløpet som er på kontoen
+- `interestRate` - et desimaltall som angir rentefot som prosentpoeng.
+
+Begge verdiene skal være satt til `0.0` når klassen opprettes.
+
+`Account`-klassen har fem metoder, med følgende oppførsel:
+
+- `deposit(double)` - øker konto-beløpet med den angitte argument-verdien (et desimaltall), men kun dersom det er positivt. Dersom det er negativt skal ingen endring skje.
+- `addInterest()` - beregner rente og legger det til konto-beløpet
+- `getBalance()` - returnerer beløpet som er på kontoen.
+- `getInterestRate()` - returnerer rentefoten
+- `setInterestRate(double)` - oppdaterer renten til å være den nye verdien
+
+## Java-kode
+
+Skriv Java-kode for `Account`-klassen med oppførsel som er beskrevet over.
+
+Lag en passende `toString()`-metode og en `main`-metode, slik at du kan sjekke at oppførselen stemmer med tilstandsdiagrammet (bruk samme start-tilstand og sekvens av kall)
+
+Testkode for denne oppgaven finner du her: [src/test/java/oving1/AccountTest.java](../../src/test/java/oving1/AccountTest.java).

oppgavetekster/oving1/Digit.md

@@ -0,0 +1,28 @@
+# Tilstand og oppførsel – Digit
+
+Oppgaven handler om en `Digit`-klasse, som representerer ett siffer i et gitt tallsystem.
+
+Tilstanden i `Digit`-objekter er todelt:
+
+- en `int` som angir tallsystemet, f.eks. 10 for titallssystemet, som oppgis i konstruktøren. Denne verdien vil ikke bli satt over 36.
+- en `int`-verdi, som representerer siffer-verdien i det angitt tallsystem og må være fra og med 0 til (men ikke med) tallsystem-verdien
+
+Konstruktøren tar inn en `int`, som initialiserer tallsystem-verdien, mens siffer-verdien settes til 0.
+
+`Digit`-tilstanden leses og oppdateres med følgende metoder:
+
+- `int getValue()` - returnerer siffer-verdien
+- `boolean increment()` - øker siffer-verdien med én. Dersom den da når tallsystem-verdien, så (re)settes den til 0 og metoden returnerer `true`, ellers returnerer den `false`.
+- `int getBase()` - returnerer tallsystemet.
+
+## Java-kode
+
+Skriv Java-kode for `Digit`-klassen med oppførsel som er beskrevet over. Lag også en `toString()`-metode som returnerer siffer-verdien som en `String`, hvor sifrene 0-9 etterfølges av A-Z. F.eks. skal siffer-verdien 10 i sekstentallssystemet gi "A" som returverdi.
+
+Lag en `main`-metode, slik at du kan sjekke at oppførselen stemmer med tilstandsdiagrammet (bruk samme sekvens av kall).
+
+Testkode for denne oppgaven finner du her: [src/test/java/oving1/DigitTest.java](../../src/test/java/oving1/DigitTest.java).
+
+## Ekstraoppgave
+
+La hovedprogrammet opprette tre `Digit`-objekter, som fungerer som sifre i et tre-sifret tall. Lag en løkke som teller fra 0 til høyest mulig verdi som kan representeres i tallsystemet. Legg så til 1 så verdien av det tre-sifrede tallet igjen blir 0. Velg selv hvilket tallsystem du vil bruke.

oppgavetekster/oving1/LineEditor.md

@@ -0,0 +1,35 @@
+# Tilstand og oppførsel – LineEditor
+
+Oppgaven handler om en `LineEditor`-klasse, som håndterer data for redigering av en linje med tekst (altså tekst uten linjeskift).
+
+`LineEditor`-klassen holder rede på en `String`-verdi og en tekstinnsettingsposisjon og har metoder for å redigere teksten. Tekstinnsettingsposisjonen er et heltall som angir hvor endringer skjer, tilsvarende en (blinkende) cursor som står mellom tegn. Verdien `0` tilsvarer foran første tegn, og høyeste mulige verdi er lengden på teksten, som tilsvarer at cursoren står bak siste tegn. Tilstanden er altså som følger:
+
+- `text` (en `String`-verdi) - teksten
+- `insertionIndex` - heltall som angir hvor i teksten redigeringer vil skje
+
+Klassen har metoder med følgende oppførsel:
+
+- `void left()` - flytter tekstinnsettingsposisjonen ett tegn til venstre (tilsvarende bruk av venstre piltast)
+- `void right()` - flytter tekstinnsettingsposisjonen ett tegn til høyre (tilsvarende bruk av høyre piltast)
+- `void insertString(String s)` - skyter teksten angitt av argumentet `s` inn i teksten på tekstinnsettingsposisjonen og forskyver tekstinnsettingsposisjonen mot høyre tilsvarende
+- `void deleteLeft()` - fjerner tegnet til venstre for tekstinnsettingsposisjonen
+- `void deleteRight()` - fjerner tegnet til høyre for tekstinnsettingsposisjonen
+- `String getText()` - Returnerer teksten
+- `void setText(String)` - oppdaterer teksten til å være den nye teksten
+- `int getInsertionIndex` - returnerer hvor i teksten redigeringer nå skjer
+- `void setInsertionIndex(int)` - oppdaterer hvor i teksten redigeringer skal skje
+
+## Java-kode
+
+Skriv Java-kode for `LineEditor`-klassen med oppførsel som beskrevet over.
+
+Lag en `toString()`-metode som viser teksten med tegnet `'|'` skutt inn på tekstinnsettingsposisjonen. Lag så en `main`-metode, slik at du kan sjekke at oppførselen stemmer med tilstandsdiagrammet (bruk samme start-tilstand og sekvens av kall).
+
+Testkode for oppgaven finner du her: [src/test/java/oving1/LineEditorTest.java](../../src/test/java/oving1/LineEditorTest.java).
+
+## Ekstraoppgave - frivillige utvidelser
+
+- Legg til metoden `void insert(Object o)`, som skyter inn en tekstlig representasjon av objektet `o` som gis som argument.
+- Legg til metoden `void left(int n)`, som flytter tekstinnsettingsposisjonen `n` tegn til venstre, og skriv om `left()` til å bruke denne. Hva bør skje dersom tekstinnsettingsposisjonen er mindre enn `n`?
+- Legg til metoden `right(int n)`, som flytter tekstinnsettingsposisjonen `n` tegn til høyre, og skriv om `right()` til å bruke denne. Hva bør skje dersom det er færre enn `n` tegn til høyre for tekstinnsettingsposisjonen?
+- Utvid tilstanden og legg til metoder for å håndtere markering av region, tilsvarende bruk av shift og piltaster i en vanlig teksteditor. Husk at også de eksisterende metodene må endres til å håndtere dette riktig.

oppgavetekster/oving1/Location.md

@@ -0,0 +1,24 @@
+# Tilstand og oppførsel – Location
+
+Oppgaven handler om en `Location`-klasse, som holder rede på `(x,y)`-posisjonen til en figur som beveger seg i et rutenett.
+
+`Location`-klassen har følgende metoder:
+
+- `up()` - beveger figuren en rute opp
+- `down()` - beveger figuren en rute ned
+- `left()` - beveger figuren en rute til venstre
+- `right()` - beveger figuren en rute til høyre
+- `getX()` - returnerer x-posisjonen til figuren
+- `getY()` - returnerer y-posisjonen til figuren
+
+Merk at konvensjonen innen datagrafikk og rutenettbaserte spill er at `x` øker mot høyre (som i matte) og `y` nedover (altså motsatt av i matte).
+
+![Koordinatsystem](./img/coordinate.png)
+
+## Java-kode
+
+Skriv Java-kode for `Location`-klassen med oppførsel som beskrevet over.
+
+Lag en passende `toString()`-metode og en `main`-metode, slik at du kan sjekke at oppførselen stemmer med tilstandsdiagrammet (bruk samme start-tilstand og sekvens av kall).
+
+Testkode for oppgaven finner du her: [src/test/java/oving1/LocationTest.java](../../src/test/java/oving1/LocationTest.java).

oppgavetekster/oving1/README.md

@@ -0,0 +1,57 @@
+# Øving 1: Objekter og klasser, tilstand og oppførsel
+
+## Øvingsmål
+
+- Bli kjent med Java-syntaks og bruk av VS Code
+- Lære (enkel) objektorientert tankegang
+- Lære å lage enkle Java-klasser og -programmer
+
+## Øvingskrav
+
+- Kunne tegne enkle tilstandsdiagrammer
+- Kunne deklarere klasser, med data og kode, iht. oppgavespesifikasjon
+- Kunne skrive main-metoder for å teste objekter
+- Kunne bruke standardtyper og -metoder (e.g. `toString()`-metoden)
+
+## NB: Viktig beskjed
+
+For å få testene og eventuell kode til øvingene lokalt brukes systemet git. Det er flere måter å hente nye øvinger:
+
+- I VS Code kan du klikke på Source Control (Venstresiden av programmet) -> Tre prikker øverst -> Pull for å hente den nye øvingen ved hjelp av dette.
+- Du kan også bruke terminalen til å skrive `git pull` i mappen til øvingen for å hente den nye øvingen.
+
+## Dette må du gjøre
+
+Oppgavene for denne øvingen skal lagres i [`src/main/java/oving1`](../../src/main/java/oving1). Test-filene som kjøres for å teste koden ligger i [`src/test/java/oving1`](../../src/test/java/oving1).
+
+Hvis du ikke allerede har gjort det, må du installere VS Code med det forhåndskonfigurerte oppsettet for TDT4100. Se [denne](https://www.ntnu.no/wiki/display/tdt4100/VS+Code) wikisiden for en guide. Dersom du opplever problemer med oppsett/installasjon send oss gjerne en melding på Teams i "Teknisk Hjelp" kanalen, still et spørsmål på Piazza eller spør din læringsassistent!
+
+### Del 1 - Tilstandsdiagram
+
+For én av oppgavene du gjør i del 2: Tegn et [objekttilstandsdiagram](https://www.ntnu.no/wiki/x/gSfuAw) for en tenkt bruk av klassen. Velg selv en passende start-tilstand og en sekvens av kall. Lag dette diagrammet før du begynner med koden.
+
+### Del 2 - Java-kode
+
+Du skal velge og gjennomføre minst tre av de følgende oppgavene angående [Tilstand og oppførsel](https://www.ntnu.no/wiki/pages/viewpage.action?pageId=65937373).
+
+- [Account (Lett)](./Account.md)
+- [Location (Lett)](./Location.md)
+- [Digit (Lett)](./Digit.md)
+- [UpOrDownCounter (Medium)](./UpOrDownCounter.md)
+- [LineEditor (Vanskelig)](./LineEditor.md)
+- [Rectangle (Vanskelig)](./Rectangle.md)
+- [StopWatch (Vanskelig)](./StopWatch.md)
+
+Oppgavene er merket med en vanskelighetsgrad relativt til hverandre. Det er en god idé å begynne med de lettere oppgavene dersom du ikke er komfortabel med pensum så langt, men det er anbefalt å prøve seg på de vanskeligere oppgavene om du synes de første oppgavene er uproblematiske. Dersom du allerede føler deg trygg på punktene i øvingskravene kan du forsøke å gå rett på de vanskeligere oppgavene. Du er selvfølgelig velkommen til å løse flere oppgaver enn minstekravet, hvilket lurt gjøres med tanke på eksamen og et langt liv som programmerende.
+
+Før du setter i gang kan det vært lurt å lese wiki-siden om [Tilstand og oppførsel](https://www.ntnu.no/wiki/pages/viewpage.action?pageId=65937373) nøye, samt ta en titt på det tilhørende `Counter`-eksempelet. Forelesningene og tilhørende øvingsforelesning er selvsagt også lure å få med seg
+
+Det finnes masse ressurser på [wikien](https://www.ntnu.no/wiki/display/tdt4100/Faginnhold) om hvordan ulike metoder skal fungere, f.eks `toString()`-metoden og ulike metoder for teksthåndtering. Naviger deg litt rundt om du lurer på noe.
+
+## Hjelp/Mistanke om bugs
+
+Ved spørsmål eller behov for hjelp konsulter studassen din i saltiden hans / hennes. Du kan også oppsøke andre studasser på sal eller legge ut et innlegg på [Piazza](https://piazza.com/ntnu.no/spring2025/tdt4100).
+
+## Godkjenning
+
+Last opp kildekode på Blackboard innen den angitte innleveringsfristen. Innlevert kode skal demonstreres for læringsassistent innen én uke etter innleveringsfrist. Se Blackboard-sidene for mer informasjon rundt organisering av øvingsopplegget og det tilhørende øvingsreglementet.

oppgavetekster/oving1/Rectangle.md

@@ -0,0 +1,51 @@
+# Tilstand og oppførsel – Rectangle
+
+Oppgaven handler om en `Rectangle`-klasse, som håndterer et firkantet område i et koordinatsystem, med sider parallelle med koordinataksene.
+
+Tilstanden i `Rectangle`-objekter er ikke spesifisert eksplisitt, men må velges slik at metodene nedenfor kan implementerers. Merk at alle metodene jobber med heltallsstørrelser.
+
+`Rectangle`-klassen har metoder for å spørre om tilstanden og endre tilstanden. Spørremetodene dekker høyde og bredde og koordinatene til øverste venstre og nederste høyre hjørne og om rektanglet inneholder spesifikke punkt(er). Endringsmetodene dekker utviding ved å legge til punkter.
+
+Logikken til metodene må tilfredsstille følgende krav:
+
+- Når en utvider et `Rectangle`-objekt med en av `add`-metodene, så skal ikke rektanglet bli større enn nødvendig, dvs. at dersom man må utvide rektangelet skal det bare utvides slik at det akkurat inneholder det nye punktet.
+- Et rektangel er tomt dersom enten bredden eller høyden er 0.
+
+Konstruktører:
+
+- `Rectangle(int x1, int y1, int x2, int y2)` - Lager et minst mulig rektangel som inneholder både punktene `(x1, y1)` og `(x2, y2)`
+
+Spørremetoder:
+
+- `int getMinX()` og `int getMinY()` - returnerer henholdsvis `x`- og `y`-koordinatene til punktet med lavest `(x,y)`-verdier som er inneholdt i dette rektanglet.
+- `int getMaxX()` og `int getMaxY()` - returnerer henholdsvis `x`- og `y`-koordinatene til punktet med høyest `(x,y)`-verdier som er inneholdt i dette rektanglet.
+- `int getWidth()` og `int getHeight()` - returnerer henholdsvis bredden og høyden til rektanglet. Begge skal returnere `0`, dersom dette rektanglet er tomt.
+- `boolean isEmpty()` - returnerer `true` om rektanglet er tomt, dvs. om bredden og/eller høyden er `0`.
+- `boolean contains(int x, int y)` - returnerer `true` om punktet `(x,y)` er inneholdt i dette rektanglet, og `false` ellers.
+- `boolean contains(Rectangle rect)` - returnerer `true` om hele `rect`, dvs. alle hjørnepunktene i `rect`, er inneholdt i dette rektanglet, og false ellers.
+
+Endringsmetoder:
+
+- `boolean add(int x, int y)` - utvider (om nødvendig) dette rektanglet slik at det (akkurat) inneholder punktet `(x,y)`. Returnerer `true` om dette rektanglet faktisk ble endret, ellers `false`.
+- `boolean add(Rectangle rect)` - utvider (om nødvendig) dette rektanglet slik at det (akkurat) inneholder hele `rect`-argumentet. Returnerer `true` om dette rektanglet faktisk ble endret, ellers `false`. Dersom `rect` er tomt, så skal dette rektanglet ikke endres.
+
+Andre metoder:
+
+- `Rectangle union(Rectangle rect)` - returnerer et nytt `Rectangle`-objekt som tilsvarer kombisjonen av dette rektanglet og `rect`-argumentet. Alle punktene som finnes i ett av rektanglene skal altså være inneholdt i rektanglet som returneres.
+
+## Java-kode
+
+Skriv Java-kode for `Rectangle`-klassen med oppførsel som er beskrevet over.
+
+Lag en passende `toString()`-metode og et hovedprogram, slik at du kan sjekke at oppførselen stemmer med tilstandsdiagrammet (bruk samme sekvens av kall).
+
+Testkode for denne oppgaven finner du her: [src/test/java/oving1/RectangleTest.java](../../src/test/java/oving1/RectangleTest.java).
+
+## Ekstraoppgave
+
+Implementer følgende metoder:
+
+- `Rectangle intersection(Rectangle rect)` - returnerer et nytt `Rectangle`-objekt som tilsvarer overlappet mellom dette rektanglet og `rect`-argumentet. Alle punktene som finnes i begge rektanglene skal altså være inneholdt i rektanglet som returneres. Dersom rektanglene ikke overlapper skal `null` returneres.
+- `boolean intersects(Rectangle rect)` - returnerer `true` om dette rektanglet og `rect`-argumentet overlapper, dvs. om det finnes ett eller flere punkter som er inneholdt i begge disse rektanglene.
+
+Testkode for ekstraoppgaven finner du her: [src/test/java/oving1/RectangleExtraTest.java](../../src/test/java/oving1/RectangleExtraTest.java).

oppgavetekster/oving1/StopWatch.md

@@ -0,0 +1,47 @@
+# Tilstand og oppførsel – StopWatch
+
+Oppgaven handler om en `StopWatch`-klasse, som implementerer en stoppeklokke med funksjoner for å starte, ta rundetider og stoppe.
+
+Klassen skal implementere logikken ofte funnet på stoppeklokker på smarttelefoner.
+
+![StopWatch](./img/stopwatch.gif)
+
+For å holde styr på tiden som går vil `StopWatch`-klassen bli kalt utenfra (altså noe du slipper å implementere i denne oppgaven) på en `tick(int)`-metode. I dataverdenen er et tick (tikk på norsk) minste målbare diskret tidsenhet. I denne oppgaven er 1 tikk = 1 millisekund. F.eks. vil et kall `tick(3)` fortelle en `StopWatch`-instans at `3` tikk har gått siden sist gang `tick()` ble kalt.
+
+> Spesielt i denne oppgaven kan det være fordelaktig å lese testene for å forstå hva som forventes av koden. Dette er en god øvelse for videre øvinger og eksamen.
+
+StopWatch skal fungere på følgende måte:
+
+- Klokken startes når man ønsker å starte tidtakningen.
+- Alle tikk etter at klokken har blitt startet skal medregnes i tidtakningen.
+- Klokken stoppes når man ønsker å stoppe tidtakningen. Da er tidtakningen helt ferdig. Det er ikke en pause i tidtakningen - klokken skal ikke startes igjen.
+- Det skal være mulig å ta rundetider.
+- Første rundetid startes når klokken starter.
+- Under tidtakningen kan man starte en ny rundetid, og dermed implisitt avslutte den nåværende.
+- Siste rundetid avsluttes når klokken stoppes.
+
+`StopWatch`-klassen må ha metoder for å spørre om tilstanden og metoder for å endre tilstanden.
+
+Klassen skal ha følgende spørremetoder:
+
+- `boolean isStarted()` - returnerer `true` om klokken har blitt startet eller `false` om den ikke har blitt startet.
+- `boolean isStopped()` - returnerer `true` om klokken har blitt stoppet eller `false` om den ikke har blitt stoppet. Merk at her snakker vi om at klokken har blitt stoppet minst én gang, ikke om klokken går eller ikke.
+- `int getTicks()` - returnerer det totale antall tikk (millisekunder) som har gått i levetiden til klokken uavhengig om klokken har vært startet eller stoppet.
+- `int getTime()` - returnerer antall tikk som har gått under tidtakningen. Hvis tidtakningen ikke har startet returner `-1`. Merk at hvis klokken er startet, men ikke stoppet, skal metoden returnere antall tikk som har gått siden klokken ble startet til nå. Hvis klokken er stoppet skal metoden returnere antall tikk som har gått fra klokken ble startet til klokken ble stoppet.
+- `int getLapTime()` - returnerer antall tikk som har gått under nåværende rundetid til nå. Hvis tidtakningen ikke har startet returner `-1`.
+- `int getLastLapTime()` - returnerer lengden på forrige avsluttede rundetid. Hvis det ikke er noen tidligere rundetider returner `-1`.
+
+Klassen skal ha følgende metoder for å endre tilstanden:
+
+- `void tick(int ticks)` - forteller klokken at `ticks` antall tikk har gått.
+- `void start()` - starter klokken.
+- `void lap()` - avslutter nåværende rundetid og starter en ny.
+- `void stop()` - stopper klokken.
+
+## Java-kode
+
+Skriv Java-kode for `StopWatch`-klassen med oppførsel som er beskrevet over.
+
+Lag en passende `toString()`-metode og en `main()`-metode, slik at du kan sjekke at oppførselen stemmer med tilstandsdiagrammet (bruk samme sekvens av kall).
+
+Testkode for denne oppgaven finner du her: [src/test/java/oving1/StopWatchTest.java](../../src/test/java/oving1/StopWatchTest.java).