1. Skapa ett paket för Tetris, med lämpligt namn -- t.ex. se.liu.ida.dinadress.tddd78.tetris.

   Paketnamnet måste innehålla "tetris" någonstans! Namnet kommer att användas av mjukvara som automatiskt separerar Tetris-kod från annan kod vid inlämning.

1. Skapa en enum-typ genom att högerklicka på Tetris-paketet i IDEA, välja New | Java Class och sätta "Kind" till Enum. Ge klassen namnet SquareType.

2. Lägg in följande inom klamrarna:
   EMPTY, I, O, T, S, Z, J, L

   Klassen ser alltså ut så här:

   public enum SquareType
   {
       EMPTY, I, O, T, S, Z, J, L
   }
   	  

   Detta betyder helt enkelt att typen SquareType har värdena SquareType.EMPTY, SquareType.I, SquareType.O, och så vidare. Eventuellt klagar IDEA på att namnen är för korta. Detta kan du ignorera.

   Här finns mer information om enum-typer om du skulle vara nyfiken på mera detaljer.

1. Skapa en main()-metod i SquareType.

2. Vi skall nu skapa ett första objekt med hjälp av operatorn new:

      Random rnd = new Random();

   Som alla klasser i Java ligger Random i ett paket. Olika paket kan ha klasser med samma namn. När du skriver in Random vill IDEA därför veta vilken Random du menar. Den ger då en popup som föreslår import av java.util.Random, den enda Random som hittas just nu. Tryck Alt+Enter för att acceptera detta. Detta resulterar i en import-sats, som skiljer sig en del från import i Python (mer om detta på en föreläsning).

   Koden deklarerar att vi vill ha ett objekt av typen Random som vi kommer att referera till med namnet rnd. Vi skickar inte med några initialiseringsparametrar till konstruktorn utan är nöjda med defaultbeteendet hos Random.

Prova att placera markören i t.ex. Random() och trycka Ctrl-Q. Detta visar javadoc i en liten popup-ruta så att du snabbt får fram information utan att behöva lämna utvecklingsmiljön och navigera genom HTML-filerna.

Så småningom ska du skriva Javadoc-kommentarer även för din egen kod. Även där fungerar Ctrl-Q för att snabbt få fram information.

Exempel från fältet "out" i System.out:

Testa att skriva "rnd." på raden under new Random();. Beroende på dina inställningar kanske rutan med möjliga fortsättningar kommer automatiskt, eller så får du ta fram den själv med Ctrl-Space.

Eftersom IDEA vet vilken typ variabeln har vet den exakt vad som kan stå efter "rnd.", vilket är ett väldigt bra sätt att lära sig mer om tillgänglig funktionalitet.

Du kan välja ett alternativ i listan eller fortsätta skriva. Om du fortsätter skriva kommer IDEA att filtrera listan och försöka hitta rätt metod utifrån det som skrivs. Skriver du t.ex. "on" kommer IDEA att föreslå " nextLong()".

Man kan navigera i alternativlistan med pil upp/ner. Man kan också trycka Ctrl-Q vilket tar fram javadoc-information för den entitet man just har markerat.

Vi ska nu skapa och skriva ut slumptal med en hjälp av Random.

1. Testa först slumptalen genom att låta main() skriva ut 25 slumptal på varsin rad. Använd valfri typ av loop för att iterera 25 gånger. Använd t.ex. nextInt(100) för att generera ett slumptal mellan 0 och 99.

2. Testkör programmet.

3. Nu ska vi även skriva ut slumpmässiga SquareType-värden.

   Med hjälp av klassmetoden (statiska metoden) SquareType.values() får vi fram en array som innehåller alla värden i enum-typen SquareType. Om vi inte har kommit till arrayer än, räcker det att veta att de fungerar ungefär som listor med fixerad längd, och att man indexerar dem som listor i Python: minArray[index], där index startar på 0. Längden får vi ut med minArray.length.

   Utifrån detta kan du fundera på hur man skapar slumptal av rätt storlek. Skriv sedan en loop som 25 gånger skriver ut en slumpmässig SquareType (ett slumpmässigt index i SquareType.values()).

4. Testkör programmet.

Vi fortsätter i samma IDEA-projekt, men skapar ett nytt paket för de enskilda övningarna i labb 2 så vi kan hålla isär de olika övningarna bättre.

1. Tidigare klasser låg i paketet se.liu.ida.dinadress.tddd78.lab1 eller se.liu.ida.dinadress.tddd78.tetris. Högerklicka src, välj New | Package och skapa se.liu.ida.dinadress.tddd78.lab2. Detta ska hamna på samma nivå som lab1 i klassträdet.

1. Skapa klassen Person i paketet lab2.

2. Addera ett privat fält med namn name av typen String som skall användas för att lagra personens namn. Eftersom varje person har sitt eget namn (som lagras i personobjektet) ska fältet inte vara static.

3. Addera ett privat fält birthDay av typen LocalDate som skall användas för att lagra personens födelsedatum. När LocalDate matas in kommer IDEA inte att känna till denna klass, men föreslå att den importeras av personklassen så att den känns igen och kan användas. Skulle man trycka bort möjligheten att låta IDEA importera LocalDate kommer IDEA att rödmarkera namnet. Ställer man markören i namnet kommer en röd lampa att tändas där man åter kan välja att IDEA skall importera klassen LocalDate.

   Här finns mer information om LocalDate för den som är intresserad.

4. Lägg till en konstruktor som tar en String och en LocalDate som inparametrar och lagrar dessa värde i objektets "privata" fält. IDEA kan snabbt skapa en konstruktor via Alt+Insert->Constructor.

5. Ett LocalDate-objekt som representerar ett datum kan t.ex. skapas med hjälp av anropet LocalDate.of(1990, 6, 1) om man vill skapa ett datum som representerar den 1:a juni 1990. Skapa en main()-metod (snabbast genom att skriva psvm och därefter trycka CTRL+Space eller CTRL-J och välja att ni vill ha en main() metod). I main()-metoden kan du skapa en person som motsvarar dig själv.

   Kör ditt testprogram och se att det inte kraschar!

1. Implementera metoden getAge() som returnerar personens ålder. Eftersom varje person har sin egen ålder (som lagras i personobjektet) ska metoden inte vara static.

2. Testa att metoden fungerar genom att skriva ut åldern på den person med dina data som skapats i main()-metoden.

Vi vill kunna skriva ut våra personer på ett läsligt format. Först provar vi vad som händer när vi skriver ut ett Person-objekt.

1. Se till att main() skriver ut minst ett Person-objekt med System.out.println().

2. Testkör. Får du ett underligt resultat, i stil med "Person@28cd724"? Då är allt rätt.

1. Tryck Alt+Insert och välj Override. Välj sedan toString().

2. Vi sätter nu ihop en sträng som får representera vår person. Man kan sätta ihop två strängar med hjälp av "+"-operatorn. Om man sätter ihop en sträng med något som inte är en sträng kommer Java att konvertera det andra objektet till en sträng. Låt toString() returnera värdet name + " " + getAge().

3. Skapa några personer till och skriv ut var och en på sin egen rad.

1. Skapa klassen Month med fälten:

   • name - månadens namn ("January")
   • number - månadens nummer (1)
   • days - antal dagar i månaden (31)

   Eftersom vi inte vill att någon skall ändra dessa värden utifrån lägger vi attributet "private" framför deklarationerna.

2. Använd IDEA för att skapa en konstruktor som initialiserar Month åt dig. Tryck Alt+Insert och välj Constructor. I detta fall ska alla fält anges som parametrar till konstruktorn, så markera alla fält innan du trycker OK.

3. Tryck Alt+Insert och välj Getter, klicka i alla tre fälten och sedan Ok. Nu genererar IDEA funktioner så att andra klasser kan få ut informationen men inte ändra den.

1. Skapa i klassen Month metoderna getMonthNumber(String name) och getMonthDays(String name) som med hjälp av switch-satser (se labb 1) rapporterar månadsnummer och antal dagar i en månad utifrån det givna månadsnamnet. Låt default: returnera -1. Då kan vi använda någon av funktionerna för att testa om en sträng faktiskt representerar en existerande månad.

   Detta ska motsvara MONTH_NUMBERS och MONTH_DAYS i Python-almanackan, men vi implementerar det som en metod istället för en dictionary.

   I just detta fall vill vi använda statiska metoder (deklarerade static). Då behöver vi inte skapa ett Month-objekt för att kunna ta reda på antal dagar i en månad, utan anropar metoderna direkt i klassen istället. Metoderna anropas därmed som Month.getMonthNumber(...). Detta ska vi bara göra för metoder som verkligen är "globala" och oberoende av information om enskilda månadsobjekt. Mer om detta kommer på senare föreläsningar.

Vi kommer inte att skapa speciella typer för timmar, minuter och dagar. Eftersom vi inte ska gå vidare och ge dessa tidsenheter mer funktionalitet än att just innehålla ett heltal, använder vi i denna labb helt enkelt int för att representera dessa. Däremot behöver vi representera datum som är sammansatta av år, dag och månad. Vi kommer också att behöva representera tidpunkter samt tidsintervall.

1. Skapa klassen Date med fälten year (int), month (Month) och day (int). Lägg till en konstruktor som tar in dessa som parametrar. Lägg också till getters för dem. Skriv en toString()-metod presenterar ett datum i ett format som du tycker är lämpligt.

2. Skapa klassen TimePoint som innehåller ett klockslag för att representera start/slut på en aktivitet. Klassen skall ha fälten hour och minute.

   I konstruktorn skall hour och minute tilldelas värden. Till skillnad från Python-almanackan tar vi in dessa som separata heltalsparametrar till konstruktorn istället för att dela upp en tidssträng i delar.

   Generera också getters för hour och minute.

   De fält och metoder vi skapar nu ska anropas i ett objekt, inte i en klass. De ska alltså inte vara statiska! Vi frågar till exempel ett specifikt Date-objekt, inte datumklassen, vilket år det har.

3. Skriv en toString()-metod i TimePoint. Använd hour och minute för att skapa en lämplig sträng att returnera. Här kan man t.ex. utnyttja String.format(...) med formatsträngen "%02d:%02d" – vi lämnar medvetet några detaljer till er att utforska!

   Överkurs
   Skapa en int compareTo(TimePoint other)-metod som returnerar -1 om den aktuella TimePoint kommer före other, 0 om de representerar samma tid och 1 om other kommer före.

4. Skapa till sist klassen TimeSpan. Den behöver två fält av typen TimePoint, start och end. Gör getters och en konstruktor som tar in dessa. Skriv sedan en toString()-metod som skapar utskrifter av typen "12:15 - 13:15". Detta görs bland annat genom anrop till toString() i start och end. På detta sätt bygger man rekursivt upp en textrepresentation av ett sammansatt objekt.

Allt som återstår nu är att lägga till en klass för möten och att skapa själva kalendern. Vi skapar en simpel kalender där alla möten lagras i en lista. En stor del av koden i metoden book() som används för att lägga möten i kalendern utgörs av parameterkontroll. Att kontrollera användarens inparametrar är ofta en stor del av den kod som ligger i ett API. Vi kommer att generera ett undantag om man försöker skapa ett otillåtet möte.

1. Skapa klassen Appointment med tre fält, subject (String), date (typ Date) och timeSpan (typ TimeSpan). Skapa getters och en konstruktor som tar samtliga som parametrar. Skapa även en toString()-metod som använder sig av Date.toString() och TimeSpan.toString() för att formattera en fin utskrift.

2. Skapa klassen Cal. Den skall ha en privat lista av appointments som realiseras av en ArrayList, vilket är en collection som implementerar list-gränssnittet, i en konstruktor utan inparametrar. Detta sker genom raderna

      private List<Appointment> appointments;

   i klassen och

      appointments = new ArrayList<>();

   i konstruktorn.

   Varför inte Calendar? Jo, det finns redan en sådan klass i Java (fast den representerar en tidpunkt), och även om det skulle fungera att ha en till, kan det vara förvirrande att ha namnkrockar med välkända klasser.
3. Implementera metoden show() som går igenom listan och skriver ut alla appointments. Detta kan med fördel göras genom att använda Live-Template (Ctrl+J) iter som leder till en så kallad for-each-loop där varje element i t.ex. en lista besöks. Denna loop har formatet "for (element : behållare)".
4. Implementera metoden

      public void book(int year, String month, int day, 
         int startHour, int startMinute, int endHour,
         int endMinute, String subject)

   Notera att vi här tar in ett månadsnamn som en sträng. Att skapa ett Date-objekt kräver däremot att vi har ett månadsobjekt. Det är upp till book() att anropa lämpliga statiska metoder i Month för att ta reda på bl.a. vilket nummer månaden har och sedan skapa ett lämpligt månadsobjekt.

   Metoden skall skall kontrollera alla inparametrar. Detta betyder att

   • year > 1970
   • För start och end är 0 <= hour <= 23 och 0 <= minute <= 59
   • month skall vara ett namn som motsvarar en existerande månad
   • månaden skall ha tillräckligt många dagar för att day skall vara tillåten

   Om någon av parametrarna är fel ska detta signaleras till anroparen. Detta gör man normalt med exceptions, "undantag". Exakt hur detta fungerar kommer vi att gå genom i en senare del av kursen. För tillfället räcker det med att ni vet att ett IllegalArgumentException ska kastas, och att detta görs med:

      throw new IllegalArgumentException("felmeddelande");

   När parametrarna är kontrollerade skall ett Date-objekt skapas utifrån datuminformationen och två TimePoint-objekt skapas som start/end. Dessa två används sedan för att skapa ett TimeSpan och slutligen ett Appointment som läggs till i listan.

5. Kalendern är nu färdig och du skall skriva ett testprogram som skapar en kalender, bokar 5-10 appointments och sedan skriver ut kalendern.

   Överkurs
   Skriv ut appointments i sorterad ordning.

1. Skapa klassen Board i Tetris-paketet.

2. Ge klassen fältet private SquareType[][] squares. Detta deklarerar en tvådimensionell array av SquareType-värden. Lägg även till privata heltalsfält width och height där konstruktorn nedan ska spara undan brädets dimensioner.

3. Ge klassen en konstruktor som tar parametrarna width och height. Låt konstruktorn sätta squares till new SquareType[height][width]. Detta skapar den faktiska arrayen som fältet ska peka på.

4. Alla positioner i arrayen är nu null, dvs. vi har en array av pekare som inte pekar på några verkliga objekt. Se till att konstruktorn fyller alla positioner i arrayen (alla kolumner i alla rader) med "tomma kvadraten" istället.

5. Gör en main-metod som helt enkelt skapar ett Board med valfri storlek. Testkör detta för att se att programmet inte kraschar, t.ex. genom att man försöker skriva utanför arrayens gränser.

1. Skapa getters för width och height i Board samt en metod för att ta reda på vilken SquareType som är lagrad i en given cell (x,y) i squares.

   Skapa inte en metod som returnerar hela squares!

1. Skapa klassen BoardToTextConverter, med metoden convertToText(Board) som returnerar en strängrepresentation av ett modellobjekt – den skriver alltså inte ut på skärmen själv utan returnerar en sträng som anroparen kan skriva ut. Tomma rutor ska då representeras med t.ex. mellanslag eller bindestreck, och olika typer på kvadrater (SquareTypes) ska representeras som textsymboler, t.ex. "#", "%" och "-".

   Du behöver en nästlad loop som itererar över rader och kolumner i lämplig ordning. Inuti loopen kan man använda en switch-sats med ett case för varje SquareType-värde, något som är möjligt på grund av att SquareType är en enum. Det vill säga, om elementet på en viss position är SquareType.EMPTY lägger du till ett mellanslag, om elementet är SquareType.I lägger du till en annan symbol, osv.

   Glöm inte radbrytningarna "\n" mellan raderna.

2. Skriv en testklass, BoardTest, som skapar en tom spelplan, konverterar den till en sträng med hjälp av ett BoardToTextConverter-objekt, och skriver ut resultatet. När det är klart har du åstadkommit ett testbart ramverk och kan se att du har gjort konkreta framsteg!

För vår testning vill vi också ha en metod för att slumpa fram en spelplan.

1. Skapa en metod i Board som kan användas för att ersätta det nuvarande innehållet i squares med genererat slumpmässigt innehåll (en slumpmässig SquareType i varje ruta).

   Som tidigare använder du ett objekt av klassen java.util.Random. Lagra Random-objektet i ett fält i Board så att du kan skapa det en gång i Board-konstruktorn och anropa det varje gång du behöver ett slumptal! Annars blir det (a) onödigt långsamt eftersom vi måste skapa många objekt i onödan, och (b) dålig kvalitet på slumptalen eftersom vi inte får en chans att utnyttja serien av slumptal.

2. Ändra klassen BoardTest så att den 10 gånger slumpar om spelplanen och skriver ut den. Testkör så att du ser att utskriften fungerar.

1. Implementera klassen Poly enligt beskrivningen ovan.

   Klassens konstruktor ska alltså ta in en array som beskriver konfigurationen hos en godtycklig polyomino. Sådana arrayer kommer sedan att skickas in av TetrominoMaker i nästa uppgift – det är där de 7 specifika blocktyperna definieras.

1. Implementera klassen TetrominoMaker enligt beskrivningen ovan.

   Tänk på att inte skapa för långa metoder – om getPoly() blir för lång när du lägger in skapandet av alla blocktyper i den metoden kan du bryta ut delar till sju olika hjälpmetoder istället.

1. Lägg till ett fält Poly falling i Board. Där ska du lagra en pekare till "den poly som just nu håller på att ramla ner", eller null om ingen poly faller just nu. Du behöver också ha koll på polyns nuvarande position (x,y), så lägg till fält för detta. Lägg slutligen till getters så att BoardToTextConverter kan få ut den fallande polyn och dess koordinater.

2. Ändra så att även den fallande tetrominon "ritas" ut (i textsträngen). Se "Hur åstadkommer vi det?" ovan.

3. Testa genom att skapa en spelplan, placera ut ett block på någon hårdkodad position, och skriva ut resultatet som text. Ser du det fallande blocket på den position där du vill ha det?

1. Skapa den nya klassen TetrisViewer.

2. På något sätt ska TetrisViewer få tillgång till ett Board-objekt. Man kunde tänka sig att TetrisViewer själv skulle skapa ett Board, men det är bättre om man istället skickar in ett Board som parameter till konstruktorn. Detta följer principen att varje klass ska ha en väl avdelad uppgift att utföra och ska inte göra något som ligger utanför den uppgiften!

   TetrisViewers uppgift är att visa en spelplan och låta oss interagera med den. Spelstartarens uppgift är (bland annat) att skapa en spelplan och ge den till ett fönster och till alla andra som kan behöva tillgång till den.

3. Vi vill nu att TetrisViewer ska kunna öppna ett fönster för att visa upp spelet. Var gör vi det?

   En möjlighet vore att lägga detta i konstruktorn. Å andra sidan kan också argumentera för att konstruktorer ska initialisera objekt men inte göra särskilt mycket "riktigt arbete". Den som anropar konstruktorn kan vänta sig att snabbt få tillbaka ett nytt objekt och sedan be det objektet att göra något, som att öppna ett fönster.

   Därför skapar vi istället en ny metod show() i TetrisViewer. Denna metod ska skapa ett fönster, en JFrame, som den ska använda för att visa upp spelet – både själva spelplanen och annan information runt omkring, till exempel poängräkning.

   JFrame representerar alltså ett GUI-fönster som kan innehålla ett antal olika komponenter såsom knappar, menyer och textrutor. Klassen har en konstruktor som saknar argument, men då får vi ingen fönstertitel. Det är bättre att anropa den JFrame-konstruktor som tar emot en fönstertitel som parameter.

   Nedan antar vi att fönsterobjektet lagras i en variabel (eller ett fält) som heter frame.

4. I show() (eller i metoder som denna anropar) ska du sedan bygga upp ett lämpligt användargränssnitt. Detta sker bland annat genom att show() lägger till komponenter i fönstret som den har skapat.

   Den viktigaste delen just nu är den JTextArea som ska användas till att visa själva "spelplanen". Skapa alltså en sådan och ange i konstruktorn till JTextArea hur många kolumner och rader som ska visas – detta avgör vilken preferred size textarean ska ha och därmed hur stor den blir på skärmen. Antalet kolumner och rader får du reda på genom att fråga det Board som konstruktorn har fått som parameter, inte genom att hårdkoda!

   Hur hittar man vilka konstruktorer som finns? I IDEA, skriv "new JTextArea(" och tryck Ctrl-P. Då får du se alla varianter på parametrar. Välj en av dem och tryck Ctrl-Q så får du dokumentation för parametrarna.

5. Textarean behöver också ges sitt första innehåll. Här förutsätter vi att du har följt instruktionerna och skrivit en BoardToTextConverter med en metod som returnerar en sträng, inte en metod som skriver ut en spelplan direkt till t.ex. System.out. Då kan du använda den metoden för att få en sträng motsvarande ett Board, och sedan använda textareans metod setText() för att sätta rätt text. Att uppdatera textarean när spelplanen ändras blir en senare uppgift.

6. I övrigt behövs en del kod i show() för att definiera fönsterlayouten, se till att fönstret visas, osv.:

   • Layouten för ett fönster hanteras av en layouthanterare som applicerar en layoutalgoritm för att placera ut komponenterna (inte genom att man själv anger koordinater för komponenterna). En lämplig start för just detta enkla fönster kan vara att TetrisViewer sätter fönstrets layouthanterare med frame.setLayout(new BorderLayout()).

   • Vi kan sedan lägga till textarean i fönstret med frame.add(textarea, BorderLayout.CENTER). CENTER placerar textarean "i mitten" i fönstret (givet att vi har just en BorderLayout som layouthanterare). Eftersom vi inte har lagt till några andra komponenter i fönstret kommer textarean att ta upp hela utrymmet i fönstret.

   • För att rutor i tetrisbrädet skall visas lika stora oavsett vilka tecken man valt att representera olika SquareTypes lägger vi till textarea.setFont(new Font("Monospaced", Font.PLAIN, 20));. Det sätter fonten till en monospaced font.

   • För att utföra layouten och göra fönstret synligt: frame.pack(); frame.setVisible(true);

7. Ändra en existerande testklass, eller skapa en ny, så att den skapar ett Board och en TetrisViewer, och som ber denna TetrisViewer att öppna ett fönster. När testet körs ska slutresultatet vara att du ser ett lagom stort fönster med en framslumpad spelplan (inte 10 spelplaner, som tidigare). Just nu finns inga menyer eller knappar för att avsluta, så du får använda "stoppknappen" i utvecklingsmiljön för att stänga av testprogrammet (eller ctrl-c i terminalfönstret).

1. Kör IDEAs kodinspektioner med profil TDDD78-2020-v1.

   • Välj Analyze | Inspect Code i menyn.
   • Välj inspektionsprofil "TDDD78-2020-v1" och tryck OK.
     Använd INTE defaultprofilen.

   Det här är till stor del ett sätt att lära sig skriva kod som inte bara gör vad den ska utan även är välskriven och strukturerad.

   Förstår du inte en varning? Utmärkt! Då har du en chans att lära dig något nytt, redan innan du lämnar in koden! Läs IDEAs inbyggda beskrivningar, läs våra utökade beskrivningar, och om det inte hjälper, fråga gärna assistenten eller examinatorn.

   Inget automatiskt inspektionsverktyg är 100% korrekt. Varningen ska alltså oftast tolkas som "har du tänkt på det här?" snarare än "du har fel!". Så småningom måste sådana kommenteras på plats i koden, med god motivering till varför varningen var "ogiltig" i detta fall. Vissa varningar kanske du vill kommentera redan nu.

   Det kan även finnas varningar som kommer från att du helt enkelt inte är klar än, t.ex. varningar för kod som inte används. De varningarna kan du så klart ignorera i det här läget.

   Saknar du inspektionsprofilen? Om du kör på universitetets datorer, och installerade IDEAs konfigurationsfiler korrekt, borde profilen finnas där. Felanmäl till oss! Om du kör hemma behöver du ladda ner konfigurationsfilerna (se "arbeta hemma"-sidan).