...
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:
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 | ||
---|---|---|
| ||
|
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 | ||
---|---|---|
| ||
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 | ||
---|---|---|
| ||
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 | ||
---|---|---|
| ||
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 | ||
---|---|---|
| ||
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
}
* Sets the patient that this doctor is treating, use null to
* indicate s/he isn't currently treating any patient.
* @param patient
*/
public void setPatient(final Patient patient) {
// Implementation hidden
}
}
/**
* A class for managing a set of doctors and the patients they're treating.
* When doctors or patients arrive, it is made sure that patients are treated
* as soon as possible.
*/
public class TreatmentUnit {
// Internal declaration hidden
/**
* Adds a doctor and makes sure s/he starts treating a patient, if one
* is waiting.
* @param doctor
*/
public void addDoctor(final Doctor doctor) {
// Possible changes
}
/**
* @return the currently available doctors
*/
public Collection<Doctor> getAvailableDoctors() {
// Possible changes
}
/**
* Adds a patient to this treatment unit, and makes sure treatment starts
* if any doctor is available.
* Otherwise the patient is queued for treatment when a doctor becomes
* available.
* @param patient
*/
public void addPatient(final Patient patient) {
// Possible changes
}
/**
* @param pred the predicate that the doctor must satisfy
* @return some doctor satisfying the predicate
*/
public Doctor getDoctor(final Predicate<Doctor> pred) {
// Possible changes
}
/**
* Find the doctor, if any, that treats the provided patient.
* @param patient
* @return the doctor treating the provided patient, or null if the
* patient isn't currently being treated.
*/
public Doctor getDoctor(final Patient patient) {
// Possible changes
}
/**
* Find all patients that are not currently being treated
* @return the patients not currently being treated
*/
public Collection<Patient> getWaitingPatients() {
// Possible changes
}
/**
* Finds a waiting patient and sets him/her as the provided doctor's patient.
* Will only accept a patient that has some condition that the doctor actually
* can treat.
* @param doctor the doctor for which a patient to treat should be found
* @return true if a patient for the provided doctor was found, false
* otherwise.
*/
private boolean startTreatment(final Doctor doctor) {
// Implementation hidden
}
/**
* Finds an available doctor for the provided patient, and sets that doctor to
* treat the patient.
* Will only accept a doctor that actually can treat some condition for the
* provided patient.
* @param patient the patient for which a treating doctor should be found
* @return true if a doctor for the provided patient was found, false
* otherwise.
*/
private boolean startTreatment(final Patient patient) {
// Implementation hidden
}
/**
* Removes the link between doctor and patient, after treatment is finished.
* If the patient is fully treated, s/he is removed from this treatment unit,
* otherwise another round of treatment is initiated.
* Also ensure the doctor starts treating another patient.
* @param doctor the doctor that has finished treating his/her patient
*/
public void treatmentFinished(final Doctor doctor) {
// Implementation hidden
}
}
Expand | ||
---|---|---|
| ||
|
Doctor-klassen er i 1a brukt for å vise grunnleggende forståelse av innkapsling, bruk av interne variable og metoder. Det legges ikke vekt på bruk av final, verken her eller i eksamen forøvrig. Den interne variable variabelen patient angir hvilken (om noen) pasient som er under av denne doktoren nå. Den bør kapsles inn, altså gjøres private, samt ha vanlige public get/set-metoder. Metoden isAvailable() skal returnere hvorvidt patient for tiden er null eller ikke. Vi trenger ingen konstruktør, da det ikke er naturlig at doktorer behandler en pasient allerede ved opprettelsen.
Merk at javadoc-en for isAvailable var motsatt av logikken vi ønsket, derfor trekkes det ikke om logikken er snudd. Vanlige feil:
|
Oppgave b)
Skriv følgende deler av klassen TreatmentUnit, basert på beskrivelsen i skjelettet:
- Avgjør og implementer den interne representasjonen av pasienter og doktorer.
- addDoctor, addPatient, getAvailableDoctors, og getWaitingPatients.
- getDoctor: Denne finnes i to versjoner, med og uten bruk av Predikat. Du skal skrive begge disse versjonene.
Vær obs på at enkelte av disse metodene bør kalle startTreatment fra 1c.
Expand | |||||
---|---|---|---|---|---|
| |||||
En TreatmentUnit har behov for å lagre en samling med doktorer som jobber der og pasienter som skal behandles (eller er under behandling). Vi har valgt vi en Collection for å lagre hver av disse, fordi det ikke er behov for indeksbasert tilgang til elementene. En annen (kanskje Set-basert) klasse som beholdt rekkefølge kunne også vært brukt). Merk at vi ikke har egne lister for doktorer som er ledige eller pasienter som venter, selv om det ville gjort noen ting enklere. Variable skal være private, med begrenset tilgang gjennom public-metoder. Det er to getDoctor-metoder, hvor getDoctor(Predicate) gjør et søk gjennom alle doktorer, og returnerer den første (om noen) som tilfredsstiller Predicate-parameteret ved kall til dennes test-metode. Den andre metoden getDoktor-metoden, getDoctor(Patient), bruker den første ved å gi inn en lambda (instans av Predicate-grensesnittet) som sjekker om doktoren har registrert denne pasienten som sin. getAvailableDoctors og getWaitingPatients er nokså like ved at de returnerer en samling objekter fra et større sett, som tilfredsstiller gitte kriterier. Disse kan forenkles hvis en har egne lister for dem, men da blir andre metoder mer kompliserte.
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 | |||||||||||||||||||||||||||
| |||||||||||||||||||||||||||
Expand | |||||||||||||||||||||||||||
|
Expand | ||
---|---|---|
| ||
|
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 | ||
---|---|---|
| ||
|
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 | ||
---|---|---|
| ||
|