TDT4100

Cheat Sheet

Formler, begreper og oppsummering

Objektorientert programmering

eksamenssett.no

Symboloversikt

Java-nøkkelord

•private / protected / public = tilgangsmodifikatorer | static = tilhører klassen
•final = kan ikke endres/arves/overstyres | abstract = ufullstendig, må implementeres
•extends = arver fra klasse | implements = implementerer grensesnitt | super = referanse til superklasse

Feilhåndtering

•try-catch-finally = fange unntak | throw = kaste unntak | throws = deklarere at metode kan kaste

Nøkkelformler per tema

Klasser og objekter

•`new ClassName()` — oppretter objekt på heapen
•`this` — referanse til nåværende objekt
•`==` — sammenligner referanser, `.equals()` — sammenligner innhold
•`static` — tilhører klassen, ikke instansen

Innkapsling og tilgangskontroll

•`private` → `protected` → package-private → `public` (tilgangsrekkefølge)
•`Objects.requireNonNull(obj, "melding")` — null-sjekk
•`Collections.unmodifiableList(list)` — read-only view
•`final` på felt = kan ikke endres etter initialisering

Arv og polymorfisme

•`extends` — arver fra klasse
•`super(args)` — kaller superklassens konstruktør
•`@Override` — markerer overskrevet metode
•`instanceof` — sjekker objektets faktiske type

Grensesnitt og abstrakte klasser

•`implements InterfaceA, InterfaceB` — implementerer grensesnitt
•`Comparable`: `compareTo(T)` returnerer negativt/0/positivt
•`Iterable`: `iterator()` — for-each-støtte
•Lambda: `(a, b) -> a.compareTo(b)`

Generics og collections

•`List`: `add(e)`, `get(i)`, `remove(i)`, `size()`
•`Set`: `add(e)`, `contains(e)`, `remove(e)`
•`Map`: `put(k,v)`, `get(k)`, `containsKey(k)`, `entrySet()`
•PECS: `` for lesing, `` for skriving

Unntakshåndtering

•`try { } catch (Type e) { } finally { }` — unntakshåndtering
•`throw new Exception("melding")` — kaste unntak
•`throws Exception` — deklarere i metodesignatur
•`try (Resource r = ...) { }` — auto-lukking

Designmønstre

•Observer: Subject → addObserver() / notifyObservers() → Observer.update()
•Strategy: Context delegerer til Strategy-grensesnitt
•Factory Method: Superklasse definerer factory-metode, subklasser implementerer
•SOLID: S-R-P, O-C-P, L-S-P, I-S-P, D-I-P

Testing og feilsøking

•`assertEquals(expected, actual)` — sjekker likhet
•`assertThrows(Exception.class, () -> ...)` — sjekker unntak
•`@BeforeEach` — kjøres før hver test (setup)
•AAA: Arrange → Act → Assert

Vanlige feil å unngå

Klasser og objekter

•Bruker `==` for å sammenligne String-innhold i stedet for `.equals()`
•Glemmer at `ref = obj` kopierer referansen, ikke objektet — endring via en referanse synes via den andre
•Forveksler instansvariabler (tilhører objektet) med lokale variabler (tilhører metoden)
•Prøver å bruke instansvariabler fra en statisk metode

Innkapsling og tilgangskontroll

•Returnerer referanse til intern mutable liste i en getter — bryter innkapslingen
•Glemmer validering i setter/konstruktør, slik at objektet kan komme i ugyldig tilstand
•Tror at `final` på en objektreferanse gjør objektet immutable — det gjør bare referansen uforanderlig
•Forveksler `protected` med `private` — `protected` gir tilgang til subklasser og hele pakken

Arv og polymorfisme

•Glemmer å kalle `super(args)` i subklassens konstruktør — gir feil hvis superklassen ikke har en standard (parameterløs) konstruktør
•Tror at `private` felt i superklassen ikke finnes i subklassen — de finnes, men er utilgjengelige direkte
•Forveksler overriding (ny implementasjon i subklasse) med overloading (flere metoder med samme navn, ulike parametere)
•Bruker arv for "har-en"-relasjoner der komposisjon er riktig

Grensesnitt og abstrakte klasser

•Glemmer å implementere ALLE abstrakte metoder fra et grensesnitt — gir kompileringsfeil (med mindre klassen er abstrakt)
•Forveksler `extends` (klasser og interface-til-interface) med `implements` (klasse implementerer interface)
•Bruker abstrakt klasse der et grensesnitt hadde gitt mer fleksibilitet
•Glemmer `@Override` — skrivefeil i metodenavn skaper en ny metode i stedet for å overstyre

Generics og collections

•Glemmer å overstyre `hashCode()` når man overstyrer `equals()` — bryter HashMap/HashSet
•Endrer en samling under iterasjon med for-each — gir ConcurrentModificationException
•Bruker `List` i stedet for `List` — primitive typer fungerer ikke med generics
•Forveksler `List.of()` (immutable) med `new ArrayList<>()` (mutable)

Unntakshåndtering

•Svelger unntak med tom catch-blokk: `catch (Exception e) {}` — alltid logg eller håndter
•Fanger for generell type (`Exception`) i stedet for spesifikk — skjuler uventede feil
•Glemmer at `finally` kjøres ALLTID, selv med `return` i try-blokken
•Forveksler `throw` (kaster unntak) med `throws` (deklarerer i metodesignatur)

Designmønstre

•Blander Observer og Strategy — Observer handler om varsling, Strategy om utskiftbare algoritmer
•Implementerer Singleton uten å tenke på trådsikkerhet
•Bruker designmønstre der enklere løsninger hadde vært tilstrekkelig — overdesign
•Glemmer at Observer gir løs kobling — subjektet skal ikke vite noe om konkrete observatører

Testing og feilsøking

•Skriver tester som avhenger av hverandre eller kjørerekkefølge
•Tester bare "happy path" og glemmer negative tester / grenseverdier
•Lager for komplekse testmetoder som tester mange ting samtidig
•Glemmer at `@BeforeEach` kjøres før HVER test — bruker `@BeforeAll` (statisk) i stedet

Eksamenstips

Klasser og objekter

•Tegn minnediagrammer (stack/heap) for å spore referanser — dette hjelper med sporingsoppgaver
•Husk at lokale variabler IKKE initialiseres automatisk, mens felt (instansvariabler) gjør det

Innkapsling og tilgangskontroll

•Sjekk alltid om innkapslingen er korrekt: private felt, validering i settere, defensive copying for mutable returverdier
•Vær forberedt på oppgaver der du skal identifisere brudd på innkapsling i gitt kode

Arv og polymorfisme

•Sporingsoppgaver: Tegn objektdiagram og følg konstruktørkjedingen ovenfra og ned
•Husk at metodevalg ved polymorfisme skjer ved kjøretid (dynamisk dispatch), mens felt bruker kompileringstidstypen

Grensesnitt og abstrakte klasser

•Vit forskjellen mellom Comparable (naturlig ordning, i klassen selv) og Comparator (ekstern, kan ha flere)
•Øv på å skrive klasser som implementerer Iterable — det dukker ofte opp på eksamen

Generics og collections

•Øv på å velge riktig datastruktur: ArrayList for indeksert tilgang, HashSet for unikhet, HashMap for oppslag
•Vær forberedt på oppgaver om equals/hashCode-kontrakten og konsekvensene av å bryte den

Unntakshåndtering

•Sporingsoppgaver: Følg kontrollflyten nøye gjennom try-catch-finally — husk at finally alltid kjøres
•Vit hvilke vanlige unntak som er checked vs. unchecked, og når man bruker hvert

Designmønstre

•Øv på å identifisere hvilke designmønstre som brukes i gitt kode
•Vær forberedt på å tegne klassediagrammer som viser relasjoner mellom klasser i et mønster
•Kjenn SOLID-prinsippene og kunne gi eksempler på brudd og løsninger

Testing og feilsøking

•Øv på å skrive JUnit-tester fra bunnen av — dette kommer ofte som oppgave
•Husk å teste både gyldige og ugyldige input, spesielt med assertThrows
•Kjenn forskjellen på @BeforeEach (per test) og @BeforeAll (en gang)

TDT4100 Formelark | Eksamenssett