Java Bootstrapping (1 week)

Skriv en annan klass med namnet MyDieTest (i en fil som heter MyDieTest.java i samma katalog). Klassen skall (endast) innehålla en main-metod som frågar användaren om önskat antal sidor och sedan skapar ett sådant Die-objekt, slår det 10 gånger och beräknar och skriver ut summan i terminalen. Se Die.java för exempel på hur man skriver en main-metod och läser data från terminalen.

Följande kod är nonsenskod som inte producerar ett vettigt resultat (försök att fundera ut varför innan du skriver ett program som utför uttrycken nedan och ser resultatet):

1: Die die = new Die();
2: System.out.println(die.get());

1%20%20Die%20die%20%3D%20new%20Die%28%29%3B%0A2%20%20System.out.println%28die.get%28%29%29%3B%0A

Vad är problemet/felet? En tärning kan visa 0!

Ändra i Die.java så att ovanstående kod blir meningsfull¹³.

Följande kod är ytterligare ett exempel på kod som inte är vettig:

1: Die die = new Die(-12);

1%20%20Die%20die%20%3D%20new%20Die%28-12%29%3B%0A

Ändra i Die.java så att det inte går att skapa tärningsobjekt med ett orimligt antal sidor! Fundera på om programmet borde krascha eller om det tyst ska sätta antalet sidor till något vettigt. Om du vill använda assert i Java måste du köra programmet med java -ea Die eller java -enableassertions Die.

Ett snyggt sätt att få koden att krascha är:

1: throw new IllegalArgumentException("Illegal number of sides for die");

1%20%20throw%20new%20IllegalArgumentException%28%22Illegal%20number%20of%20sides%20for%20die%22%29%3B%0A

Pröva vad följande kod ger för utskrift:

1: Die d = new Die();
2: System.out.println(d);

1%20%20Die%20d%20%3D%20new%20Die%28%29%3B%0A2%20%20System.out.println%28d%29%3B%0A

Lägg till följande metod i Die-klassen:

1: public String toString() {
2:     return "Die(" + value + ")";
3: }

1%20%20public%20String%20toString%28%29%20%7B%0A2%20%20%20%20%20%20return%20%22Die%28%22%20%2B%20value%20%2B%20%22%29%22%3B%0A3%20%20%7D%0A

och se vad det då blir för utskrift. Fundera över varför! Om du använde IllegalArgumentException ovan, använd strängkonkatenering¹⁴ för att ändra utskriften till “-12 is an illegal number of sides for a die!”

Lägg till en metod i klassen Die med signaturen boolean equals(Die otherDie) som returnerar true om tärningarna “är likadana” (vad betyder det?), annars false. Tänk också på skillnaden mellan “samma tärning” och “likadana tärningar”.

Nu är det dags att skriva en egen klass – PairOfDice – som representerar ett tärningspar. I Java måste en publik klass ligga i en fil som heter samma sak som klassen, så börja med att skapa filen PairOfDice.java och öppna den i Emacs.

Klassen PairOfDice skall använda sig av (“aggregera” med OO-terminologi) klassen Die, d.v.s. den skall ha två attribut av typen Die och metoderna i PairOfDice skall använda metoder i klassen Die. Operationer som skall finnas:

• Skapa ett tärningspar med givet antal sidor (samma för båda tärningar),
• slå båda tärningarna samtidigt och returnera resultatet,
• avläsa varje enskild tärning, samt
• en toString()-metod.

Gå till online-dokumentationen för Javas klass-API (JDK) och skumma dokumentationen för String-klassen. Läs om compareTo-metoden och skriv sedan ett nytt program som läser in två namn i strängform (med hjälp av Scanner-klassen) och skriver ut dem i bokstavsordning.

1. Skapa en klass NameOrder i filen NameOrder.java. Klassen skall vara publik. Det är okej att placera all logik i dess main()-metod.
2. Deklarera main()-metoden som public static void main(String[] args).
3. I main()-metoden, deklarera två lokala variabler String name1 och String name2. Tilldela variablerna från inläsning med Scanner på samma sätt som gjorts ovan.
4. Använd compareTo() i en if-sats för att välja utskriftsordning.

Frivillig utökning: gör sorteringen skiftlägesokänslig.

Skriv ett lämpligt driver-program som kapslar in nedanstående kod i en main-metod, och förklara beteendet (ledning: Tänk på skillnaden mellan identitet och ekvivalens!).

String a = "Beefheart";
String b = "Beefheart";
String c = "heart";
String d = "Beef" + c;
int i = 1;
int j = 1;
Integer k = 2;
Integer l = i + j;
System.out.println(a == b);
System.out.println(a.equals(b));
System.out.println(a == d);
System.out.println(a.equals(d));
System.out.println(i == j);
System.out.println(k == i + j);
System.out.println(k.equals(i+j));
System.out.println(k == l);
System.out.println(k.equals(l));

String%20a%20%3D%20%22Beefheart%22%3B%0AString%20b%20%3D%20%22Beefheart%22%3B%0AString%20c%20%3D%20%22heart%22%3B%0AString%20d%20%3D%20%22Beef%22%20%2B%20c%3B%0Aint%20i%20%3D%201%3B%0Aint%20j%20%3D%201%3B%0AInteger%20k%20%3D%202%3B%0AInteger%20l%20%3D%20i%20%2B%20j%3B%0ASystem.out.println%28a%20%3D%3D%20b%29%3B%0ASystem.out.println%28a.equals%28b%29%29%3B%0ASystem.out.println%28a%20%3D%3D%20d%29%3B%0ASystem.out.println%28a.equals%28d%29%29%3B%0ASystem.out.println%28i%20%3D%3D%20j%29%3B%0ASystem.out.println%28k%20%3D%3D%20i%20%2B%20j%29%3B%0ASystem.out.println%28k.equals%28i%2Bj%29%29%3B%0ASystem.out.println%28k%20%3D%3D%20l%29%3B%0ASystem.out.println%28k.equals%28l%29%29%3B%0A

Nedanstående övningar blandar in arv. Du kan vänta med den här delen tills arv har tagits upp på en föreläsning.

Skriv en klass ColoredDie som representerar en tärning som har en viss färg (låt färgen representeras som en sträng). Låt den ärva av klassen Die. Vilka metoder bör du specialisera (eng. “override”)? Vilka nya metoder är vettiga att ha? Ändra sedan i klassen PairOfDice så att en av de skapade tärningarna är röd och den andra tärningen har en slumpvis vald färg.

Metoden equals() som du skrev ovan har problemet att den bara kan anropas med en tärning som argument. Med andra argument anropas istället motsvarande metod ur klassen Object (alla klasser ärver av Object), och den metoden kanske inte gör vad vi vill. För att specialisera equals måste den ha typen boolean equals(Object other). Skriv om equals så att den kan anropas med argument av godtycklig typ. Du kan använda operatorn instanceof för att ta reda på om ett värde är (en subtyp av) en viss klass (men det här är ett av få vettiga tillfällen att använda instanceof!).

En kund i vårt system behöver hålla koll på hur många varor hen har i sin korg samt vid vilken tidpunkt hen kom in i systemet. Följande attribut borde räcka:

• int bornTime - tidssteget som kunden kom in i systemet
• int groceries - antalet varor i kundens korg

Förutom en konstruktor behövs (åtminstone) följande metoder:

• serve() - registrera en av kundens varor (alltså minska på groceries)
• isDone() - fråga om kunden är färdig, dvs. om groceries är 0.

En kund behöver inte vara medveten om att tiden går (bornTime och groceries påverkas ju inte av tiden).

Pröva att skriva en main()-metod i Customer som skapar en kund med ett antal varor och anropa serve() tills isDone() är sant.

En kassa måste veta om den är öppen eller stängd, samt hålla koll på kunderna som står i kö:

• boolean open - true om kassan är öppen, annars false
• Queue queue - En kö av kunderna som väntar på att behandlas. Kunden som står längst fram i kön är den som får sina varor behandlade.

Förutom en konstruktor behövs (åtminstone) följande metoder:

• open() - öppna kassan.
• close() - stäng kassan.
• isOpen() - är kassan öppen?
• step() - låt tiden gå ett steg i kassan. Det betyder att kunden som står först i kön får en vara registrerad.
• hasCustomers() - har kassan några kunder?
• currentCustomerIsDone() - är kunden som står längst fram i kön klar?
• addToQueue(Customer c) - ställ kunden c sist i kön.
• removeCurrentCustomer() - ta bort (och returnera) kunden som står först i kön.
• getQueueLength() - hur lång är kön?.

Notera att många av metoderna är lätta att implementera med hjälp av metoderna i klassen Queue!

Här kan du välja att “fuska” genom att låtsas att Queue redan är implementerad, t.ex. genom att skapa en Queue-klass med mer eller mindre tomma metoder.

Observera att Java kommer med länkade listor, köer, stackar, arrayer, etc. – det går bra att använda dessa för att implementera Queue, men det duger inte för att redovisa mål på just länkade strukturer.

En kö ser ut ungefär som en länkad lista, med skillnaden att man alltid lägger till element i ena änden och tar bort element i den andra. Precis som en länkad lista består en kö ett antal noder (nedan kallad Node, som med fördel kan ligga nästlad i Queue). En nod ser ut precis som länken i en länkad lista:

• Customer element - Kunden som står på just den platsen i kön
• Node next - Noden för platsen bakom den nuvarande.

I klassen Queue behövs referenser till första och sista noden i kön:

• Node first - Noden som håller det första elementet
• Node last - Noden som håller det sista elementet
• int length - Antalet kunder i kön just nu (frivilligt, men praktiskt att ha)

Förutom en konstruktor behövs (åtminstone) följande metoder:

• length() - Hur lång är kön?
• enqueue(Customer c) - Ställ en kund sist i kön
• dequeue() - Ta bort (och returnera) kunden som står först i kön.
• first() - Returnera (men ta inte bort) kunden som står först i kön.

Eftersom vi bara är intresserade av kassorna representeras själva varuhuset bara av en array av kassor:

• Register registers[] - kassorna i varuhuset

Arrayer i Java fungerar som i C, dvs. de är konsekutivt allokerade utrymmen som indexeras från 0 med samma syntax som i C. Dock håller arrayer i Java koll på sin längd. Man kan t.ex. skriva registers.length för att få veta hur många element som finns i registers. Vidare, om man försöker accessa ett element som inte finns, t.ex. registers[12] när registers.length == 10 kommer att ge upphov till en krasch där felmeddelandet anger vilken rad felet uppstod på och att felet berodde på att vi accessar utanför arrayen (ArrayOutOfBoundsException).

Konstruktorn kan med fördel ta antalet kassor som argument, och bör öppna minst en av sina kassor. Förutom en konstruktor behövs (åtminstone) följande metoder:

• getAverageQueueLength() - vad är snittlängden för alla kassor i varuhuset?
• newCustomer(Customer c) - ställ kunden c i den kortaste kön.
• step() - tiden går ett steg i varuhuset.
• openNewRegister() - öppna en ny kassa (om det går).
• getDoneCustomers() - returnera alla kunder som är klara i det nuvarande tidssteget.

Det här är klassen som håller koll på tiden och all statistik, och avgör när det kommer nya kunder och när det är dags att öppna nya kassor. Det är också den här klassen som tar emot simuleringens alla parametrar. Följande attribut är en bra början:

• Store store - varuhuset som simuleras
• int time - antalet tidssteg sedan simuleringen startade
• int intensity - sannolikheten (i procent) att det ska komma en ny kund vid varje tidssteg.
• int maxGroceries - maxantalet varor som en kund kan ha när hen kommer till kassan.
• int thresholdForNewRegister - vid vilken snittlängd en ny kassa öppnas.

Det kan också vara en bra idé att ha attribut för den statistik man samlar.

Förutom en konstruktor behövs nästan bara metoden step() som driver simuleringen framåt ett tidssteg. Detta bör ske i följande steg:

1. Låt tiden gå ett steg i varuhuset.
2. Slumpa ett heltal mellan 0 och 100 om heltalet är mindre än intensity, skapa en ny kund och skicka den till varuhuset. Antalet varor i kundens korg slumpas fram mellan 1 och maxGroceries.
3. Hämta snittlängden på kassaköerna i varuhuset. Om den är högre än thresholdForNewRegister, öppna en ny kassa.
4. Hämta alla kunder som är klara och samla in statistik från dem.

Du bör också ha metoder för att returnera den insamlade statistiken.

Simulator är given och innehåller bara programmets main()-metod som skapar en ny Simulation och anropar step() på den ett visst antal gånger. Varje step()-anrop motsvarar en “puls” genom systemet. Mellan varje tidssteg skrivs simuleringen ut och tråden som kör pausas i en halv sekund.

Det går förstås bra att ändra i Simulator om man vill, till exempel genom att låta programmet läsa in parametrar från en fil eller från kommandoradsargumenten.

Börja med att rita! Vilka klasser finns det? Hur hänger de samman, dvs. vilka funktioner fyller de för varandra? (Dvs. vilka metoder kommer klass X att använda hos klass Y, etc.) Fundera också över skillnaden mellan klasser och objekt (instanser av klasser) – det finns en kö-klass, men hur många köer finns det?

Nu är det dags att börja implementera! Börja med att skriva klassen Customer. Skriv ett enkelt program som testar att kund-klassen fungerar som den ska. Till exempel: skapa en kund med tre varor, anropa serve tre gånger och kontrollera att kunden är klar (med isDone). Ett förslag finns i CustomerTest.java.

Den enda klassen du kan skriva härnäst är Queue (Register är beroende av Queue, Store är beroende av Register, Simulation är beroende av Store…). Börja med att skriva ett enkelt testprogram (som bara har en main-metod) som skapar en kö och några kunder, ställer kunderna i kön, plockar ut dem och kontrollerar att de kommer ut i rätt ordning.

Själva klassen Queue är som sagt beroende av att det finns en klass för köns noder. Klassen Node kan med fördel vara definierad som en klass i samma fil som klassen Queue, och får därför inte vara publik (men ej heller privat)¹⁸. Du väljer själv om du vill ha get- och set-metoder för att läsa och skriva nodernas attribut eller om du vill komma åt dem direkt (jämför this.first.getNext() och this.first.next).

Ett specialfall att tänka på är vad som händer om man försöker ta bort en kund ur en kö som redan är tom. Om detta händer är något förmodligen fel i programmet, så det är ett bra tillfälle att kasta ett undantag¹⁹. Du kan skapa en klass för eget undantag på följande vis

public class EmptyQueueException extends RuntimeException{}

public%20class%20EmptyQueueException%20extends%20RuntimeException%7B%7D%0A

och sen kasta undantaget genom att skriva throw new EmptyQueueException(). Detta kommer att riva ned programmet. Senare skall vi lära oss hur man kan fånga denna typ av fel och återhämta sig från dem²⁰.

Nästa klass att skriva är Register. Precis som tidigare kan du testa den här klassen separat genom att skapa en kassa och några kunder, låta tiden gå några steg och kontrollera att kunderna behandlas som de ska. Notera att metoden step bara behandlar den första kunden. Det är Store:s ansvar att plocka ut kunden när hen är klar.

När kassaklassen är klar kan du skriva Store, som består av en samling kassor i en array. Många av metoderna går ut på att iterera över alla kassor och göra något särskilt. I Java kan du använda for-loopar för att iterera över en samling:

for(Register r : this.registers) {
    ...
}

for%28Register%20r%20%3A%20this.registers%29%20%7B%0A%20%20%20%20...%0A%7D%0A

Loopen ovan kommer att iterera över hela this.registers och i varje steg av loopen binda r till en av kassorna i arrayen.

Metoden getDoneCustomers() ska returnera en samling av kunder. Du kan använda en array, din egen Queue eller någon datastruktur från Javas standardbibliotek.

Det lättaste sättet att testa klassen är förmodligen att skapa en Store, lägga in ett par kunder med kända parametrar och anropa step och getDoneCustomers för att kontrollera att kunderna behandlas som de ska. Om något inte verkar funka kan du skriva ut hela varuhuset mellan varje steg för att se hur kunderna rör sig. Det är också en bra förberedelse för det sista steget:

Sist kan du skriva klassen Simulation. Den viktigaste metoden är step, som beskrevs i mer detalj tidigare. Du kommer att behöva slumpa fram några tal. För att göra det kan du låta klassen ha följande attribut:

Random random = new Random();

Random%20random%20%3D%20new%20Random%28%29%3B%0A

Du måste importera java.util.Random för att den klassen ska hittas. När du har ett Random-objekt på det sättet kan du anropa random.nextInt(100) för att slumpa fram ett heltal mellan 0 och 100.

Du kan välja själv mellan att ha flera metoder som alla returnerar varsin bit av statistiken, eller om du vill skapa en klass som lagrar all statistik och ha en metod som returnerar ett sådant objekt.

Notera den magiska raden

System.out.print("\033[2J\033[;H");

System.out.print%28%22%5C033%5B2J%5C033%5B%3BH%22%29%3B%0A

Den rensar skärmen så att det går att göra animationer av det slag som visades på exempelfilmen tidigare i detta dokument.