...
Expand | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Denne første versjonen av systemet består av tre klasser. Patient er en tom klasse. Doctor-klassen har en assosiasjon til en Patient. TreatmentUnit holder rede på hvilke pasienter og doktorer som finnes, og styrer avvikling av behandlingskøen. Pasienter som har blitt behandlet av en lege fjernes fra systemet. Pasientene har altså ingen (helse)tilstander her.
Oppgave a)Skriv ferdig Doctor-klassen i henhold til skjelettet, altså nødvendige innkapslingsmetoder og isAvailable. Patient er så langt en tom klasse, du trenger ikke implementere denne.
Oppgave b)Skriv følgende deler av klassen TreatmentUnit, basert på beskrivelsen i skjelettet:
Oppgave b)Skriv følgende deler av klassen TreatmentUnit, basert på beskrivelsen i skjelettet:
Vær obs på at enkelte av disse metodene bør kalle startTreatment fra 1c.
Oppgave c) - TreatmentUnit: Koble pasient og doktorHver gang en ny pasient eller lege er lagt til, eller en lege har avsluttet en behandling, bør TreatmentUnit forsøke å koble en ledig lege og en pasient som skal behandles. Implementer de to startTreatment-metodene og treatmentFinished (sistnevnte brukes ikke i denne underoppgaven, men senere).
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Expand | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Expand | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
Expand | ||
---|---|---|
| ||
Vi velger igjen Collection, fordi vi ikke trenger indeksbasert tilgang til conditions. Det kan derimot også gjerne brukes et sett (Set-grensesnittet og HashSet-implementasjonsklassen). Vi har valgt å ha en tom konstruktør og en addConditions-metoden, en kunne gjerne hatt en konstruktør som tar inn tilstander i stedet, siden en jo ikke trenger å legge til tilstander underveis i behandlingsforløpet, bare fjerne dem (removeConditions). addConditions(…): Denne skal ta inn en samling, og vi har valgt å bruke varargs, i stedet for å ta inn en Collection. requiresTreatment(): Pasienten trenger behandling dersom conditions ikke er tom. removeConditions(…): Denne fjerner de angitte tilstandene, og vi valgte å ta inn en Collection, da det er praktisk både der den brukes og for implementasjonen. Implements Iterable og iterator()-metoden: Disse gir støtte for å iterere over tilstandene til en pasient, og hente ut en og en tilstand, for eksempel i en for-løkke. Dette ivaretar innkapsling, siden den underliggende lista ikke eksponeres (mer enn nødvendig). public class Patient implements Iterable<String> {
private Collection<String> conditions = new ArrayList<>(); // 2a
public void addConditions(String... conditions) { // 2a this.conditions.addAll(Arrays.asList(conditions)); }
public boolean requiresTreatment( ) { // 2a return ! conditions.isEmpty(); }
public void removeConditions(Collection<String> conditions) { // 2a this.conditions.removeAll(conditions); }
@Override public Iterator<String> iterator() { // 2a return conditions.iterator(); } } |
Oppgave 2b) - Doctor
Implementer følgende deler av Doctor-klassen i henhold til skjelettet:
- Avgjør intern lagring av tilstander legen kan behandle. Du trenger ikke argumentere for valget.
- Konstruktør: Tenk spesielt på innkapsling av data for å hindre endring fra utenfor klassen. Velg selv parameterliste.
- canTreat: For en gitt pasient skal metoden returnere andelen av dennes tilstander som doktoren kan behandle. Hvis Jens har fem tilstander, og Dr. Who kan behandle tre av dem, så skal metoden returne tallet 0.6.
- treat: For en gitt pasient fjernes de tilstandene som doktoren kan behandle.
Expand | ||
---|---|---|
| ||
Intern lagring av tilstander en doktor kan behandle håndteres greit med en Collection, List er unødvendig jamfør samme problemstilling som i Patient. Konstruktør: Den skal håndtere et sett med tilstander doktoren kan kurere, som er av typen String. Her er det enda mer naturlig enn for Patient å bruke konstruktøren til å sette tilstandene, siden det i hvert fall er lite behov for å endre kompetansen til doktoren i løpet av et behandlingsforløpet. Merk at Arrays.asList gir en Collection som ikke kan endre størrelse. canTreat(): Gå gjennom alle tilstandene pasienten har (utnytter at Patient implementerer Iterable), og teller dem og hvilke av dem denne doktoren kan behandle. Merk hvordan telleren må gjøres om til double før divisjonen, så resultatet ikke avkortes til 0. treat(): Denne metoden gjelder pasienten som er under behandling (satt med setPatient) og fjerner alle tilstander hos pasienten som denne doktoren kan behandle. Dette krever en egnet removeConditions-metode i Patient, detaljene kan variere. public class Doctor {
private Collection<String> competencies; // 2b
public Doctor(String... competencies) { // 2b this.competencies = Arrays.asList(competencies); }
public double canTreat(Patient patient) { int count = 0, total = 0; for (String item : patient) { total++; if (competencies.contains(item)) { count++; } } return ((double) count) / total; }
public void treat() { patient.removeConditions(competencies); } } |
Oppgave 2c - TreatmentUnit
Nå som pasienter har ulike tilstander, og doktorer kan behandle slike tilstander, må dette taes hensyn til i klassen TreatmentUnit. En doktor kan ikke behandle pasienter den ikke har kompetanse til å behandle, og en pasient må være i systemet helt til alle tilstander er behandlet.
- Implementer endring i TreatmentUnit i relevante metoder. Du trenger ikke kopiere inn metoder som ikke endrer seg fra del 1, du skal heller ikke endre svar i del 1.
Expand | ||
---|---|---|
| ||
De eneste metodene som blir påvirket, og dermed må endres, er de to startTreatment-metodene og treatmentFinished. Her må en passe på å respektere dokumentasjonen når det gjelder returverdier som true og false. startTreatment(Doctor): Som før går en gjennom alle pasientene som trenger behandling (getWaitingPatients), men nå sjekker vi også om doktoren faktisk har kompetanse til å gjøre noe med pasientens tilstander vha. et kall til doctor.canTreat(patient). Vi prøver ikke å finne pasienten med størst behandlingspotensiale, altså størst canTreat-resultat. startTreatment(Patient): Vi går som tidligere gjennom alle de ledige doktorer (getAvailableDoctors), og som over, sjekker vi en ledig doktor har relevant kompetanse (canTreat). Her gjør vi heller ingenting for å finne beste doktor for denne pasientens tilstander. treatmentFinished(): Forskjellen fra del 1 er at vi nå sjekker om pasienten er ferdigbehandlet eller trenger mer behandling (requiresTreatment). Hvis så er tilfelle trigger vi (forsøk på) behandling med startTreatment(patient), ellers fjernes pasienten fra pasientlista. Som før så får doktoren som er ferdig (muligens) en ny pasient vha. startTreatment(doktor).
private boolean startTreatment(Doctor doctor) { // 2c for (Patient patient : getWaitingPatients()) { if (doctor.canTreat(patient) > 0.0) { doctor.setPatient(patient); return true; } } return false; }
private boolean startTreatment(Patient patient) { // 2c for (Doctor doctor : getAvailableDoctors()) { if (doctor.canTreat(patient) > 0.0) { doctor.setPatient(patient); return true; } } return false; }
public void treatmentFinished(Doctor doctor) { // 2c if (doctor.getPatient() == null) { throw new IllegalStateException(doctor + " has no patient!"); } Patient patient = doctor.getPatient(); doctor.setPatient(null); if (patient.requiresTreatment()) { startTreatment(patient); } else { patients.remove(patient); } startTreatment(doctor); } |
Oppgave 2d - Testing
Du har fått utdelt et skjelett med halvferdige testmetoder (TreatmentUnitTest). Gjør testmetodene fullstendige i henhold til kommentarene. Du vil finne dokumentasjon av testing i vedlegget nederst på siden.
Expand | ||
---|---|---|
| ||
LF beskriver testene på en kompakt måte, det er ingen ting i veien for å dele dem opp litt. For øvrig er det lite å bemerke ved løsningen.
public class TreatmentUnitTest {
private TreatmentUnit treatmentUnit;
@Before public void setUp() { treatmentUnit = new TreatmentUnit(); }
@Test public void testAddDoctorsPatient() { Doctor doctor1 = new Doctor("flu"); Doctor doctor2 = new Doctor("noseblead"); treatmentUnit.addDoctor(doctor1); treatmentUnit.addDoctor(doctor2); assertTrue(doctor1.isAvailable() && doctor2.isAvailable()); Patient patient = new Patient(); patient.addConditions("flu", "noseblead"); // 2e) start sequence diagram treatmentUnit.addPatient(patient); assertTrue(! (doctor1.isAvailable() && doctor2.isAvailable())); Doctor patientDoctor = treatmentUnit.getDoctor(patient); patientDoctor.treat(); treatmentUnit.treatmentFinished(patientDoctor); // 2e) end sequence diagram assertTrue(patientDoctor.isAvailable()); assertNotSame(patientDoctor, treatmentUnit.getDoctor(patient)); patientDoctor = treatmentUnit.getDoctor(patient); patientDoctor.treat(); treatmentUnit.treatmentFinished(patientDoctor); assertTrue(doctor1.isAvailable() && doctor2.isAvailable()); } } |
Oppgave 2e) - Sekvensdiagram
Tegn sekvensdiagram av det som skjer mellom start sequence diagram- og end sequence diagram-kommentarene i testklassen i skjelettkoden. Diagrammet skal inkludere testen selv, akuttmottaket, pasienten og doktoren som (i den delen av testen) deltar i behandlingen. Du skal ikke ha med kode du legger til selv (f.eks. kall til assert-metoder), som svar på 2 d).
Det skulle være omtrent 8-10 kall til metoder i denne delen.
Expand | ||
---|---|---|
| ||
Løsningsforslaget beskriver hele flyten, og inkluderer kall og objekter som oppstår som et resultat av treatmentFinished(). Kommentaren om antall kall var litt misvisende, siden det var meningen å flytte end sequence diagram-markøren én linje opp, altså over kallet til treatmentFinished(). Løsningen er derfor mer omfattende enn antydet, noe vi må ta hensyn til ved sensuren. |
title | Del 3 - arv (20%) |
---|
Fokus i del 3 er organisering av objektorientert kode med arv. Oppgaven kan derfor løses ved hjelp av pseudokode.
Systemet skal støtte tre ulike logikker for å knytte doktor til pasient:
- Pasienter knyttes til den første (men ikke nødvendigvis beste) doktoren som kan behandle en eller flere tilstander hos pasienten. (TreatmentUnit)
- Pasientene kan ha tilstander med varierende kritikalitet, som gjør at de prioriteres foran resten av køen når en doktor er ledig. Gjør nødvendige antakelser om en getPriority-metode som brukes til prioritering. Per, som har en mer alvorlig skade enn Jens, vil altså behandles raskere selv om han kommer inn senere. (Såfremt ikke Jens allerede har startet behandling.) (PriorityTreatmentUnit)
- Pågående pasientbehandling (selv om den er prioritert som over) skal kunne avbrytes og doktoren skal starte behandling av en ny pasient. Dette skal skje dersom det kommer inn en ny pasient, og dennes prioritet er høyere enn hos den som er til behandling. Du kan også her forutsette at det finnes en getPriority-metode i Patient. Anta at Jens er under behandling hos doktor Who. Ida kommer til behandling, har en tilstand med høyere prioritet enn Jens, og kan kun behandles av Who. Jens sin behandling blir derfor satt på vent, og den samme doktoren begynner behandling av Ida. (EmergencyPriorityTreatmentUnit)
I denne deloppgaven skal du beskrive eller implementere støtte for disse egenskapene ved å bruke arv. Du finner ikke noe nytt skjelett til denne oppgaven, men du vil finne skjelettet fra del 2 for oppslag.
Vi ønsker å ende opp med tre klasser, TreatmentUnit, PriorityTreatmentUnit og EmergencyPriorityTreatmentUnit, som implementerer hver sin logikk i lista over. Forskjellen dem i mellom skal være hvordan de implementerer startTreatment-metodene. De skal være knyttet sammen med arv for å gjøre det enkelt for andre klasser å bytte mellom dem og for å gi god gjenbruk, men detaljene i hvordan arvingsmekanismen brukes skal være opp til deg. Det er lov å innføre ekstra klasser og metoder i arvingshierarkiet, hvis det gjør løsningen bedre.
Forklar med tekst og kode hvordan du vil 1) strukturere arvingshierarkiet og 2) hvilke metoder som deklareres/implementeres hvor. Skriv også kode for metodene. Siden fokuset her er mer på objektorientert organisering av kode, vil det også gis poeng for pseudokode.
title | Skjelett til del 2 gjentatt for oversikt over metoder |
---|
/**
* A patient has a set of conditions (of type String) that needs to be treated.
*/
public class Patient {
/**
* Indicates if this patient has conditions that needs to be treated.
* @return true if this patient has conditions that needs to be treated,
* false otherwise.
*/
public boolean requiresTreatment() { // 2a
// Implementation hidden
}
}
/**
* A doctor has the capacity to treat one patient at a time.
* The doctor as a list of competencies (of type String) that
* indicates what conditions s/he can treat.
*/
public class Doctor {
/**
* Initialise this doctor with a set of competencies.
* @param competencies
*/
public Doctor(...) { // 2b
// Implementation hidden
}
/**
* Indicates to what extent this doctor can treat the provided patient.
* The value is the number of the patient's conditions this doctor can
* treat divided by the number of conditions the patient has.
* Conditions and competences are matched using simple String comparison.
* @param patient
* @return the ratio of the patient's conditions that this doctor
* can treat.
*/
public double canTreat(final Patient patient) { // 2b
// Implementation hidden
}
/**
* "Treats" the patient by removing all the patient's conditions
* that this doctor can treat.
*/
public void treat() { // 2b
// Implementation hidden
}
/**
* @return the patient this doctor is treating, or null if s/he
* isn't currently treating any patient.
*/
public Patient getPatient() {
// Implementation hidden
}
/**
* @return true if this doctor is currently treating a patient,
* otherwise false.
*/
public boolean isAvailable() {
// Implementation hidden
}
Valinge feil /alternative løsninger:
|
Oppgave c) - TreatmentUnit: Koble pasient og doktor
Hver gang en ny pasient eller lege er lagt til, eller en lege har avsluttet en behandling, bør TreatmentUnit forsøke å koble en ledig lege og en pasient som skal behandles. Implementer de to startTreatment-metodene og treatmentFinished (sistnevnte brukes ikke i denne underoppgaven, men senere).
Expand | |||||
---|---|---|---|---|---|
| |||||
startTreatment(Doctor) finner en pasient å tilordne en doktor (som har kommet på jobb eller er blitt ledig), ved å velge første (om noen) av de som venter på behandling (getWaitingPatients). Finner vi en pasient, settes doktoren sin pasient og true returneres, eller returneres false. startTreatment(Patient): Denne likner veldig på den første, men er fra en pasient sitt perspektiv. Her tas det utgangspunkt i ledige doktorer (getAvailableDoctors). Finnes ingen ledig doktor returneres false, ellers settes den første doktoren i samlingen til pasienten det er snakk om, og true returneres. Her kan ville det vært en fordel om getAvailableDoctors returnerte en liste, siden vi trenger å ta ut element på en bestemt indeks (0). treatmentFinished(Doctor): Vi har valgt å utløse et unntak av type IllegalStateException hvis doktoren ikke har noen til behandling. Koblingen mellom doktor og pasienten fjernes setPatient(null)-kallet. Siden pasientene i del 1 ikke har noen (helse)tilstander slik de får i del 2, er de ferdig behandlet og kan da fjernes fra systemet med patients.remove(patient). Og siden doktoren nå blir ledig, så trigges behandling av en ny pasient med et kall til startTreatment.
Vanlige feil/alternative løsninger:
|
Expand | |||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| |||||||||||||||||||||||||||||||||||||||||||||||||||||||
Alle pasienter har på forhånd blitt diagnostisert med en eller flere (helse)tilstander (conditions) som må behandles. Tilsvarende har alle doktorer et sett med tilstander som de er kompetente til å behandle. En doktor kan ikke behandle pasienter den ikke har kompetanse til å behandle, og en pasient må være i systemet helt til alle tilstander er behandlet.
Oppgave 2a) - PatientImplementer følgende deler av Patient-klassen i henhold til skjelettet:
Oppgave 2b) - DoctorImplementer følgende deler av Doctor-klassen i henhold til skjelettet:
Oppgave 2c - TreatmentUnitNå som pasienter har ulike tilstander, og doktorer kan behandle slike tilstander, må dette taes hensyn til i klassen TreatmentUnit. En doktor kan ikke behandle pasienter den ikke har kompetanse til å behandle, og en pasient må være i systemet helt til alle tilstander er behandlet.
Oppgave 2d - TestingDu har fått utdelt et skjelett med halvferdige testmetoder (TreatmentUnitTest). Gjør testmetodene fullstendige i henhold til kommentarene. Du vil finne dokumentasjon av testing i vedlegget nederst på siden.
Oppgave 2e) - SekvensdiagramTegn sekvensdiagram av det som skjer mellom start sequence diagram- og end sequence diagram-kommentarene i testklassen i skjelettkoden. Diagrammet skal inkludere testen selv, akuttmottaket, pasienten og doktoren som (i den delen av testen) deltar i behandlingen. Du skal ikke ha med kode du legger til selv (f.eks. kall til assert-metoder), som svar på 2 d). Det skulle være omtrent 8-10 kall til metoder i denne delen.
Vanlige feil/alternative løsninger:
|
Expand | ||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||
Fokus i del 3 er organisering av objektorientert kode med arv. Oppgaven kan derfor løses ved hjelp av pseudokode. Systemet skal støtte tre ulike logikker for å knytte doktor til pasient:
I denne deloppgaven skal du beskrive eller implementere støtte for disse egenskapene ved å bruke arv. Du finner ikke noe nytt skjelett til denne oppgaven, men du vil finne skjelettet fra del 2 for oppslag. Vi ønsker å ende opp med tre klasser, TreatmentUnit, PriorityTreatmentUnit og EmergencyPriorityTreatmentUnit, som implementerer hver sin logikk i lista over. Forskjellen dem i mellom skal være hvordan de implementerer startTreatment-metodene. De skal være knyttet sammen med arv for å gjøre det enkelt for andre klasser å bytte mellom dem og for å gi god gjenbruk, men detaljene i hvordan arvingsmekanismen brukes skal være opp til deg. Det er lov å innføre ekstra klasser og metoder i arvingshierarkiet, hvis det gjør løsningen bedre. Forklar med tekst og kode hvordan du vil 1) strukturere arvingshierarkiet og 2) hvilke metoder som deklareres/implementeres hvor. Skriv også kode for metodene. Siden fokuset her er mer på objektorientert organisering av kode, vil det også gis poeng for pseudokode.
|
Expand | ||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||||||||||
Mens du i del 3 brukte arv, skal du i denne delen bruke delegering for å oppnå det samme. I henhold til delegeringsteknikken definerer vi et grensesnitt, DoctorAllocator. I tillegg lager du (minst) tre hjelpeklasser tilsvarende de tre logikkene beskrevet i del 3, som implementerer grensesnittet. Forklar hvordan koden i vedlagte TreatmentUnit-skjelett skal gjøres fullstendig slik at startTreatment-metoden bruker delegering riktig. Forklar også med tekst og/eller kode hvordan du vil utforme hjelpeklassene som implementerer DoctorAllocator. Da målet er å vise kunnskap om delegering kan dere bruke pseudokode i denne oppgaven. Det er greit å referere (pseudo)koden i del 3, hvis det er til hjelp.
Vi gjentar fra del 3 hvordan vi ønsker å knytte doktor til pasient, men dette skal nå gjøres ved å implementere DoctorAllocator i stedet for å bruke arv:
|
Expand | |||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| |||||||||||||||||||||||||||
På venterommet skal det være et informasjonspanel, som forteller ventende pasienter om hvilken doktor de skal gå til, når det er deres tur. Panelet implementeres med JavaFX, og tanken er at kontroller-objektet (av typen TreatmentUnitController ) skal lytte på et TreatmentUnit-objekt og få beskjed når koblingen mellom doktor og pasient etableres, slik at panelet kan vise en tekst av typen «Pasient X skal gå til Doctor Y» (du kan forvente at Patient og Doktor har en toString() som gir navn, dette trenger du ikke implementere i tidligere oppgaver). I denne delen kan du bygge videre på koden fra del 2. Du trenger altså ikke ha løst del 3 eller 4.
Oppgave 5a) – Lyttergrensesnitt
Oppgave 5b) – Controller Fyll ut kodeskjelettet for kontrollerklassen TreatmentUnitController, slik at det fungerer med den vedlagte FXML-koden og fyller rollen som observatør av TreatmentUnit. Som indikert i kodeskjelettet, så kan du anta at treatmentUnit-variablen i kontrollerklassen settes «automagisk» i konstruktøren.
|
Expand | ||
---|---|---|
| ||
TreatmentUnit: Løsningsforslaget viser utvidelse med en abstrakt klasse AbstractTreatmentUnit. Denne klassen implementerer alle metoder som ikke involverte regelsett for hvordan en skulle start behandling, og deklarerer de relevante abstrakte metoden (startTreatment *2). Disse ble så implementert i TreatmentUnit, med løsning akkurat som i del 2. En slik abstrakt klasse er ikke påkrevd, men en god idé, fordi den tydeliggjør hva som er ment å variere (polymorfi) i subklassene.
PriorityTreatmentUnit: Her skulle en velge ut den ventende pasienten som hadde høyest prioritet (getPriority). Selv om getPriority ikke ble oppgitt kunne en gjøre antakelser om bruk. Den eneste metoden som måtte implementeres i denne klassen var startTreatment(Doctor), siden prioritering må gjøres hver gang det oppstår en situasjon der pasientene konkurrerer om en doktor som er ankommet eller blitt ledig. Forskjellen fra tidligere implementasjon er at en må gå igjennom alle pasienter (som denne doktoren kan behandle) og lagre den pasienten som til nå har høyest prioritet. Vi har også vist pseudokode som vil være en fullgod besvarelse for denne klassen.
EmergencyPriorityTreatmentUnit: Den eneste metoden som trenger ny logikk er startTreatment(Patient). Derfor er det lurt (men strengt tatt ikke nødvendig) å arve fra PriorityTreatmentUnit, siden vi da kan utnytte den eksisterende prioriteringslogikken. Det er jo bare når en ikke finner en doktor med super.startTreatment(patient) at ny logikk for å avbryte pågående behandling er aktuell. Hvis dette er tilfelle, må en gå igjennom alle doktorer (trenger ny hjelpemetode getAllDoctors-metode) og sjekke om denne doktoren kan behandle pasienten. Merk at vi utelater alle ledige doktorer, siden disse allerede er sjekket i kallet til superklassens metode (dette kan forsåvidt skje i den nye hjelpemetoden, som da kanskje bør hete getAllTreatingDoctors). Vi bruker samme logikk som tidligere for å velge ut den lavest prioriterte pasienten. Vi oppdatere dennes nåværende doktor sin pasient til den nye pasienten (getDoctor(patientToSuspend).setPatient(patient)). Til slutt må pasienten som fikk avbrutt behandlingen få en ny sjanse til behandling av en annen lege med et nytt kall til startTreatment. Det er ganske mange ting å huske på, men det viktigste er tross alt god bruk av arv.
Også her tillates pseudokode, se eksempel i LF. Merk at oppgaven beskrev klassen PriorityTreatment, mens LF kaller den PriorityTreatmentUnit. Det er selvsagt ikke viktig.
public class PriorityTreatmentUnit extends TreatmentUnit {
protected double getPriority(Patient patient) { return 0.0; }
@Override protected boolean startTreatment(Doctor doctor) { Patient patient = null; for (Patient patient2 : getWaitingPatients()) { if (doctor.canTreat(patient2) > 0.0 && (patient == null || getPriority(patient2) > getPriority(patient))) { patient = patient2; } } if (patient != null) { doctor.setPatient(patient); return true; } return false; } }
/* PSEUDOKODE-eksempel FOR startTreatment(doctor) * Går gjennom alle pasienter som venter (getWaitingPatients()) og * holder rede på den med høyest prioritet (getPriority). * Sjekker om det finnes en doktor * med riktig kompetanse (canTreat) * Hvis man har funnet en pasient som kan behandles, * så får doktoren denne (setPatient) og true returneres. */
public class EmergencyPriorityTreatmentUnit extends PriorityTreatmentUnit {
@Override public boolean startTreatment(Patient patient) { if (! super.startTreatment(patient)) { Patient patientToSuspend = null; for (Doctor doctor : getAllDoctors()) { if (doctor.canTreat(patient) > 0.0) { Patient existingPatient = doctor.getPatient(); if (existingPatient != null && getPriority(existingPatient) < getPriority(patient) && (patientToSuspend == null || getPriority(existingPatient) < getPriority(patientToSuspend))) { patientToSuspend = existingPatient; } } } if (patientToSuspend != null) { getDoctor(patientToSuspend).setPatient(patient); startTreatment(patientToSuspend); return true; } } return false; } } |
title | Del 4 - delegering (15%) |
---|
Mens du i del 3 brukte arv, skal du i denne delen bruke delegering for å oppnå det samme. I henhold til delegeringsteknikken definerer vi et grensesnitt, DoctorAllocator. I tillegg lager du (minst) tre hjelpeklasser tilsvarende de tre logikkene beskrevet i del 3, som implementerer grensesnittet. Forklar hvordan koden i vedlagte TreatmentUnit-skjelett skal gjøres fullstendig slik at startTreatment-metoden bruker delegering riktig. Forklar også med tekst og/eller kode hvordan du vil utforme hjelpeklassene som implementerer DoctorAllocator.
Da målet er å vise kunnskap om delegering kan dere bruke pseudokode i denne oppgaven. Det er greit å referere (pseudo)koden i del 3, hvis det er til hjelp.
title | Skjelett til del 4 |
---|
public interface DoctorAllocator {
/**
* Finds the patient in the TreatmentUnit that the provided doctor
* should start treating.
* Note: The method should be free of side effects, i.e. should not modify any object.
* @param doctor
* @param treatmentUnit
* @return the patient that the doctor should treat, or null.
*/
public Patient allocatePatient(Doctor doctor, TreatmentUnit treatmentUnit);
/**
* Finds the doctor in the TreatmentUnit that the provided patient
* should be treated by.
* Note: The method should be free of side effects, i.e. should not modify any object.
* @param patient
* @param treatmentUnit
* @return The doctor that should treat the provided patient, or
* null if none was found.
*/
public Doctor allocateDoctor(Patient patient, TreatmentUnit treatmentUnit);
}
/**
* A class for managing a set of doctors and the patients they're treating.
* When doctors or patients arrive, or a doctor finishes a treatment,
* it is made sure that patients are treated as soon as possible.
*/
public class TreatmentUnit {
// Implementation of local variables hidden
public void addDoctor(final Doctor doctor) {
// Implementation hidden
}
public Collection<Doctor> getAllDoctors() {
// Implementation hidden
}
public Collection<Doctor> getAvailableDoctors() {
// Implementation hidden
}
public void addPatient(final Patient patient) {
// Implementation hidden
}
public Doctor getDoctor(final Predicate<Doctor> pred) {
// Implementation hidden
}
public Doctor getDoctor(final Patient patient) {
// Implementation hidden
}
public Collection<Patient> getAllPatients() {
// Implementation hidden
}
public Collection<Patient> getWaitingPatients() {
// Implementation hidden
}
... declarations related to the use of DoctorAllocator ... // Part 4
protected boolean startTreatment(final Doctor doctor) { // Part 4
final Patient patient = ... use of DoctorAllocator here ...
... more code here ...
}
protected boolean startTreatment(final Patient patient) { // Part 4
final Doctor doctor = ... use of DoctorAllocator here ...
... more code here ...
}
public void treatmentFinished(final Doctor doctor) {
// Implementation hidden
}
}
Expand | ||
---|---|---|
| ||
LF lager løsningen rundt det oppgitte grensesnittet DoctorAllocator, som har to metoder allocateDoctor og allocatePatient. Dette grensesnittet implementeres av en DefaultDoctorAllocator (noe som tilsvarer slik det gjøres i en vanlig TreatmentUnit, altså ikke noe bruk av prioritering). De andre to proriteringsstrategiene implementeres av PriorityDoctorAllocator og EmergencyPriorityDoctorAllocator. LF bruker arv for begge disse, tilsvarende løsningen i del 3, men det er ikke viktig fordi temaet her er delegering. Logikken som implementeres er omtrent som i del 3, med en vesentlig forskjell: Grensesnitt-metodene skal bare finne og returnere riktig doktor/pasient (koblingen som skal etableres), ikke endre noe, altså kalles ikke setPatient eller startTreatment.
DefaultDoctorAllocator: Implementerer ingen prioritet og tilsvarer et vanlig TreatmentUnit-valg. Hvis doktor-pasient-kobling kan etableres returneres doktor eller pasient, ellers null.
PriorityDoctorAllocator: Arver fra DefaultDoctorAllocator, så en slipper unna med redefinering av allocatePatient, med logikk tilsvarende PriorityTreatmentUnit.
EmergencyPriorityDoctorAllocator: Arver fra PriorityDoctorAllocator, så en slipper unna med redefinering av allocateDoctor, med logikk tilsvarende EmergencyPriorityTreatmentUnit.
TreatmentUnit: Denne må endres så den 1) bruker delegering ved å kalle en DoctorAllocator-implementasjon og 2) håndterer faktisk endring av doktor-pasient-koblingen, iht. resultatet fra DoctorAllocator-implementasjonen. Delegering rigges ved å opprette en doctorAllocator-variabel, her er DefaultDoctorAllocator valgt, men den kan byttes ut med et kall til setDoctorAllocator. Begge startTreatment-metodene må endres. For begge består endringen av at en må kalle den tilsvarende allocate-metoden og sjekke om resultatet er null før en knytter relasjonen. Merk at en må ta høyde for at behandling kan avbrytes.
public interface DoctorAllocator {
/** // Long description at git */ public Patient allocatePatient(Doctor doctor, TreatmentUnit treatmentUnit);
/** // Long description at git */ public Doctor allocateDoctor(Patient patient, TreatmentUnit treatmentUnit); }
public class DefaultDoctorAllocator implements DoctorAllocator {
@Override public Patient allocatePatient(final Doctor doctor, final TreatmentUnit treatmentUnit) { for (final Patient patient : treatmentUnit.getWaitingPatients()) { if (doctor.canTreat(patient) > 0.0) { return patient; } } return null; }
@Override public Doctor allocateDoctor(final Patient patient, final TreatmentUnit treatmentUnit) { for (final Doctor doctor : treatmentUnit.getAvailableDoctors()) { if (doctor.canTreat(patient) > 0.0) { return doctor; } } return null; } }
public class PriorityDoctorAllocator extends DefaultDoctorAllocator {
/** * Dummy class */ protected double getPriority(final Patient patient) {
return 0.0; }
@Override public Patient allocatePatient(final Doctor doctor, final TreatmentUnit treatmentUnit) { Patient patient = null; for (final Patient patient2 : treatmentUnit.getWaitingPatients()) { if (doctor.canTreat(patient2) > 0.0 && (patient == null || getPriority(patient2) > getPriority(patient))) {
patient = patient2; } } return patient; } }
public class EmergencyPriorityDoctorAllocator extends PriorityDoctorAllocator {
@Override public Doctor allocateDoctor(final Patient patient, final TreatmentUnit treatmentUnit) { final Doctor doctor = super.allocateDoctor(patient, treatmentUnit); if (doctor != null) { return doctor; } Patient patientToSuspend = null; for (final Doctor doctor2 : treatmentUnit.getAllDoctors()) { if (doctor2.canTreat(patient) > 0.0) { final Patient existingPatient = doctor2.getPatient(); if (existingPatient != null && getPriority(existingPatient) < getPriority(patient) && (patientToSuspend == null || getPriority(existingPatient) < getPriority(patientToSuspend))) { patientToSuspend = existingPatient; } } } if (patientToSuspend != null) { return treatmentUnit.getDoctor(patientToSuspend); } return null; } } |
Vi gjentar fra del 3 hvordan vi ønsker å knytte doktor til pasient, men dette skal nå gjøres ved å implementere DoctorAllocator i stedet for å bruke arv:
- Pasienter knyttes til den første (og ikke nødvendigvis beste) doktoren som kan behandle en eller flere tilstander hos pasienten.
- Pasientene kan ha tilstander med varierende kritikalitet, som gjør at de prioriteres foran resten av køen når en doktor er ledig. Du kan forutsette at det finnes en getPriority-metode i Patient, og at denne prioriteten settes ved innlegging av pasientdata. Per, som har en mer alvorlig skade enn Jens, vil altså behandles raskere selv om han kommer inn senere. (Såfremt Jens ikke allerede har startet behandlingen.)
- Pågående pasientbehandling (selv om den er prioritert) skal kunne avbrytes og doktoren skal starte behandling av en ny pasient. Dette skal skje dersom det kommer inn en ny pasient, og dennes prioritet er høyere enn hos pågående. Du kan også her forutsette at den finnes en getPriority-metode i Patient. Anta at Jens er under behandling hos doktor Who. Ida kommer har en tilstand med høyere prioritet enn Jens, og kan kun behandles av Who. Jens sin behandling blir derfor satt på vent, og den samme doktoren begynne behandling av Ida.
title | Del 5 – observatør-observatør-teknikken og JavaFX (15%) |
---|
På venterommet skal det være et informasjonspanel, som forteller ventende pasienter om hvilken doktor de skal gå til, når det er deres tur. Panelet implementeres med JavaFX, og tanken er at kontroller-objektet (av typen TreatmentUnitController ) skal lytte på et TreatmentUnit-objekt og få beskjed når koblingen mellom doktor og pasient etableres, slik at panelet kan vise en tekst av typen «Pasient X skal gå til Doctor Y» (du kan forvente at Patient og Doktor har en toString() som gir navn, dette trenger du ikke implementere i tidligere oppgaver).
I denne delen kan du bygge videre på koden fra del 2. Du trenger altså ikke ha løst del 3 eller 4.
title | Skjelett til del 5 |
---|
// TreatmentUnit.fxml:
<?xml version="1.0" encoding="UTF-8"?>
<?import javafx.scene.layout.VBox?>
<?import javafx.scene.control.Label?>
<?import javafx.scene.layout.HBox?>
<?import javafx.scene.text.Font?>
<HBox xmlns:fx="http://javafx.com/fxml/1" fx:controller="ord2019.part5.TreatmentUnitController">
<Label fx:id="patientMessage" text="<Her kommer meldinger til pasienter>">
</Label>
</HBox>
// TreatmentUnitController.java:
public class TreatmentUnitController {
TreatmentUnit treatmentUnit;
public TreatmentUnitController() {
treatmentUnit = // assume treatmentUnit is set automatically.
... 5 b) other initialization ...
}
... 5 b) declarations and methods here...
}
Oppgave 5a) – LyttergrensesnittDefiner et egnet lyttergrensesnitt og forklar med tekst og kode hvordan TreatmentUnit må endres for å kunne fungere som observert i et observatør-observert-forhold.
Expand | ||
---|---|---|
| ||
Standardteknikken krever et passende lyttergrensesnitt og en liste av lyttere som kalles på passende sted. En bruker gjerne en Collection for å lagre lytterne og add/remove-metoder for å administrere lytterne. LF definerer lyttergrensesnittet TreatmentListener. Dette grensesnittet har én metode, som kalles idet doktor-pasient-koblingen etableres, altså på tidspunktet det passer å gi beskjed til pasienten om hvilken doktor hen skal gå til. Metoden bør ta inn faktisk pasient, doktor og akuttmottak (TreatmentUnit). Endringer som må gjøres i den observerte, TreatmentUnit, er at alle lytterne lagres i en private Collection av type TreatmentListener, og at den legger inn relevante public add/remove til denne. I tillegg defineres hjelpemetoden fireTreatmentStarted, som kalles rett etter at setPatient har etablert en ny doktor-pasient-kobling (i både startTreatment(Doctor) og startTreatment(Patient)). public interface TreatmentListener {
public void treatmentStarted(Doctor doctor, Patient patient, TreatmentUnit treatmentUnit);
}
public class TreatmentUnit {
// Lots of code unchanged here, find it in part 2 of TU.
private Collection<TreatmentListener> treatmentListeners = new ArrayList<>();
public void addTreatmentListener(TreatmentListener listener) { treatmentListeners.add(listener); }
public void removeTreatmentListener(TreatmentListener listener) { treatmentListeners.remove(listener); }
private void fireTreatmentStarted(Doctor doctor, Patient patient) { for (TreatmentListener treatmentListener : treatmentListeners) { treatmentListener.treatmentStarted(doctor, patient, this); } }
private boolean startTreatment(Doctor doctor) { for (Patient patient : getWaitingPatients()) { if (doctor.canTreat(patient) > 0.0) { doctor.setPatient(patient); fireTreatmentStarted(doctor, patient); return true; } } return false; }
private boolean startTreatment(Patient patient) { for (Doctor doctor : getAvailableDoctors()) { if (doctor.canTreat(patient) > 0.0) { doctor.setPatient(patient); fireTreatmentStarted(doctor, patient); return true; } } return false; } } |
Oppgave 5b) – Controller
Fyll ut kodeskjelettet for kontrollerklassen TreatmentUnitController, slik at det fungerer med den vedlagte FXML-koden og fyller rollen som observatør av TreatmentUnit. Som indikert i kodeskjelettet, så kan du anta at treatmentUnit-variablen i kontrollerklassen settes «automagisk» i konstruktøren.
Expand | ||
---|---|---|
| ||
I FXML-koden ser en at det finnes en Label med fx:id="patientMessage". Her må man skjønne/gjette at det er dette objektet som skal oppdateres når en pasient skal gå til en doktor. En kan også lese at controlleren er en (instans av) TreatmentUnitController. TreatmentUnitController: - Label patientMessage i FXML må knyttes til en variabel i TreatmentUnitController, gjennom å bruke @FXML-annotasjonen og Label-type. - Konstruktøren oppretter en ny TreatmentUnit. Så er det litt valgfritt hva som skjer, men den viktige biten er at man i konstruktøren også må opprette forbindelsen mellom TreatmentUnitController som lytter/observatør og TreatmentUnit som observert vha. et kall til addTreatmentListener-metoden fra 5a. - TreatmentUnitController må implementere lyttergrensesnittet og (den ene) lyttermetoden må oppdaterer status på Label-objektet.
public class TreatmentUnitController implements TreatmentListener {
private TreatmentUnit treatmentUnit;
public TreatmentUnitController() { treatmentUnit = new TreatmentUnit();
// …
treatmentUnit.addTreatmentListener(this); }
@FXML private Label patientMessage;
@Override public void treatmentStarted(Doctor doctor, Patient patient, TreatmentUnit treatmentUnit) { patientMessage.setText(patient.getName() + " bes gå til doktor " + doctor.getName()); } } |