Page History

...

I denne oppgaven tar vi utgangspunkt i en Person-klasse som at en person har et navn (String) bestående av fornavn ("given name") og etternavn ("family name") som sammen gir personens fulle navn ("full name").

Exercise-panelet 

Bruk av Exercise-panelet er obligatorisk for denne øvingen. Du må ha panelet åpent med Named.ex-filen (tests > interfaces > Named.ex) i før du begynner med oppgaven. For mer informasjon/hjelp, se nederst på forrige side, altså hovedsiden for Øving 6.

Del 1

Definer et grensesnitt Named med innkapslingsmetoder for fornavn, etternavn og fulle navn.  følgende metoder:

• setGivenName(String) og String getGivenName() for å sette og hente fornavn
• setFamilyName(String) og String getFamilyName() for å sette og hente etternavn
• setFullName(String) og String getFullName() for å sette og hente personens hele navn. Argumentet til set-metoden skal være fornavn og etternavn skilt med mellomrom. Tilsvarende skal get-metoden returnere fornavn og etternavn skilt med mellomrom.

Del 2

Lag en Person-klasse som klassene Person1 og Person2 som begge implementerer grensesnittet Named. Person-klassen kan ha enten ett eller to felter for personnavnet avhengig av hva man finner enklestPerson1-klassen skal ha felter for for- og etternavn (altså givenName og familyName) og en konstruktør som tar inn to tilsvarende argumenter. Person2 skal ha ett felt for fullt navn (fullName) og en konstruktør som tar inn det fulle navnet. Begge skal imidlertid implementere samme logikk, dvs. ha get- og set-metoder for fornavn, etternavn og fullt navn. Man kan anta at brukere brukeren oppretter Person Person1 og Person2-objekter med gyldige navn, altså trenger man ikke å implementere valideringsmetoder.

Del 3

--------------------------------

Resten er foreløpig sakset fra Card-oppgaven...

Vi tar i denne oppgaven utgangspunkt i en Card-klassen fra kortoppgaven om objektstrukturer. Et Card-objekt har en kortfarge (av typen char) og verdi (int), og sortering gjøres på disse verdiene, ved at en først sorterer på kortfarge og så på verdi. Siden Java har sortering innebygget, så trenger vi ikke bry oss om selve sorteringsalgoritmen, men fokuserer her på logikken for sammenligning av Card-objekter.

Del 1

La Card-klassen implementere Comparable med følgende sammenligningslogikk

• compareTo-metoden skal sammenligne et kort med et annet, slik at spar vurderes som høyere enn hjerter, hjerter høyere enn ruter og ruter høyere enn kløver. Ved lik kortfarge skal verdien brukes, altså 1 (ess) er mindre enn 2 er mindre enn 3 osv. til og med 11 (knekt), 12 (dame) og 13 (konge).

Del 2

For å kunne sortere Card-objekter med annen logikk, så kan bruke grensesnittet Comparator, som er et objekt som kan sammenligne objekter parvise, typisk de som skal sorteres. Implementer en Comparator (dvs. lag en klasse som implement Comparator) kalt CardComparator, som kan konfigureres (stilles inn) til å sortere med ess som høyeste kort og med en bestemt kortfarge som trumf, altså en kortfarge som regnes som høyere enn de andre

• CardComparator må ha en konstruktør som tar inn en boolean og en char. boolean-argumentet sier om ess skal regnes som størst (true) eller minst (false) og char-argumentet angir hvilke kortfarge som er trumf. F.eks. skal et CardComparator-objekt laget med new CardComparator(true, ' ') rangere ess høyere enn konge og bruke standard rangering av kortfarger (siden trumf-argumentet ikke er en av kortfargene), og et CardComparator-objekt laget med new CardComparator(false, 'C') rangere ess lavest og kløver ('C' = clubs) høyest av kortfargene (de andre kortfargene har standard rangering med spar over hjerter over ruter).

Ekstraoppgave

Utvid CardComparator slik at den kan konfigureres med en annen rangering av kortfargene, f.eks. slik at kløver er høyere enn ruter. Merk at denne fortsatt skal overstyres av evt. trumf. Nytten er altså at en kan endre rangeringsrekkefølgen på alle på én gang.

JExercise-testkode for del 1 og del 2 finner du her: interfaces/CardComparatorTest.java

For å kunne sammenligne Named-objekter, f. eks. for å sortere en kontaktliste, kan du lage en klasse kalt NamedComparator, som implementerer grensesnittet Comparator. NamedComparator-objektet skal brukes for å sammenligne navn parvis: Først på etternavn og deretter på fornavn om etternavnene er like. Dette kan gjøres ved å la NamedComparator-klassen implementere metoden int compare(Named named1, Named named2) med følgende logikk: 

• Dersom etternavnene er ulike skal metoden
  • returnere et negativt heltall om det første etternavnet er alfabetisk ordnet før det andre,
  • eller et positivt heltall i motsatt tilfelle.
• Dersom etternavnene er like skal metoden gjøre det samme på fornavnene. Dersom også fornavnene er like skal metoden returnere 0.

Skriv testkode som bruker Collections.sort-metoden på en ArrayList<Named>, for å teste om NamedComparator-klassen har implementert Comparator riktig.

Hint: For å sammenlikne to String-objekter kan man bruke String-klassens innebygde Comparable-metode int compareTo(String streng2). Denne metoden sammenlikner en String med en annen alfabetisk.

Testkode for oppgavene finner du her:
interfaces/NamedComparatorTest.java, 
interfaces/Person1Test,
interfaces/Person2Test.
Originalkoden (jextest) for testen finner du her:
interfaces/NamedComparator.jextest, 
interfaces/Person1.jextest, 
interfaces/Person2.jextest.