Vi vill komma igång snabbt! Otåliga som vi är bestämmer vi oss för att skapa en cirkelklass, utan att tänka så mycket på framtiden eller hur den ska kopplas till övriga formklasser.

1. Skapa paketet se.liu.dinadress.shapes för den här labben. Lägg även detta paket "bredvid" lab1 och övriga paket (högerklicka mappen motsvarande ditt liuid i IDEA, och välj New / Package).

2. Skapa klassen Circle i paketet shapes.

3. Lägg till de publika (public!) int-fälten x, y och radius.

4. Lägg till ett publikt fält color av typen java.awt.Color.

   Abstract Window Toolkit (AWT) är Javas ursprungliga grafiksystem. Anledningen till att vi skriver hela java.awt.Color är att det finns många Color-klasser i olika paket och vi vill testa ett alternativt sätt att få fram exakt rätt klass. Om du ställer markören i java.awt.Color så kommer IDEA att visa en glödlampa till vänster. Klicka på den eller tryck Alt+Enter, och välj Replace qualified name with import, så kommer IDEA att istället importera klassen och vi kan använda namnet utan att ange paketdelen (java.awt).

5. Skapa en konstruktor som tar in parametrar och tilldelar värden till alla fält.

Vi gör nu ett första test av klassen. Även om vi är otåliga ska detta göras tidigt för att vi inte ska låta eventuella fel få nya följdfel när vi fortsätter programmera.

1. Skapa klassen CircleTest och en main()-metod i den.

2. I main() ska vi skapa en lista av Circle. Skriv new ArrayList<Circle>(), låt IDEA importera ArrayList, och testa IDEAs Extract Variable enligt nedan.

   Info: Extract Variable

   Genom att markera ett uttryck eller stå i en variabel kan man snabbt få IDEA att introducera en variabel som representerar detta. Man gör det med Refactor | Extract | Variable: Ctrl-Alt-V. Det är användbart t.ex. då man vill skapa en variabel snabbt. Anta att vi har skrivit i koden:

      new ArrayList<Circle>()

   Efter att vi trycker Ctrl-Alt-V och väljer namn på variabeln får vi:

      final ArrayList<Circle> circles = new ArrayList<>();

   IDEA har själv hittat på ett variabelnamn, som man givetvis kan byta ut. Notera att "<>" står för "samma typparametrar som tidigare på raden", dvs. "<Circle>".

   Extract Variable är också användbart om man har ett långt uttryck som man vill dela upp, t.ex. en if-sats där villkoret är väldigt långt. Genom att markera en del av den och ta extract variable skapas en variabel som tilldelas värdet av deluttrycket och sedan ersätts detta i if-satsen med variabeln.

3. Skapa ett par cirklar och lägg dem i listan (med listmetoden add()).

4. Använd live-template iter (iterate collection) för att skapa en for-loop som går igenom varje Circle i listan och för varje cirkel skriver ut dess x- och y-koordinater. När man fyller i en live-template kan man använda Tab för att navigera mellan variabler som namnges.

   Notera att iter använder en for-loop-variant som är mer lik Pythons:
   for (Type element : collection), som itererar en gång för varje element i en samling eller array.

5. Kör programmet och verifiera att du får ut rätt utskrifter.

1. Hoppa från CircleTest till Circle genom att använda Navigate | Class: Ctrl-N, filtrera genom att skriva "Cir", och trycka Enter på rätt klass. Detta är en mycket användbar genväg.

   Eftersom vi redan har en referens till Circle i närheten kan vi även ställa markören i Circle och trycka Ctrl-B för att snabbt hoppa till definitionen, eller ctrl-klicka Circle. Detta fungerar för alla klasser, metoder och fält, inklusive de från "språkets egna" klasser (t.ex. System).

2. Lägg till följande rader överst i Circle-konstruktorn:

       if (radius < 0) {
           throw new IllegalArgumentException("Negativ radie!");
       }
   

   Detta är en exception, ett undantag. Vi kommer att gå genom mer om exceptions i kursen, men hittills räcker det att veta att denna kod avbryter konstruktorn och signalerar ett fel till anroparen. Eftersom konstruktorn avbröts skapas heller inget cirkelobjekt!

Detta exemplifierar två viktiga programmeringsbegrepp.

• En klass har kontroll över sina objekt. Nu kan ingen skapa en cirkel med negativ radie.

• Defensiv programmering. Vi ska inte tänka att "ingen galning skulle få för sig att ge en negativ radie, så det fallet kan vi ignorera". Man vet aldrig hur radien räknas ut eller vad anroparen har missat att tänka på (eller hur galen någon är, för den delen). Vi tar hand om alla tänkbara och otänkbara fall, så får vi färre svårhittade buggar.

1. Ställ markören i klassen Circle – inte bara i filen Circle.java, utan inuti class Circle { ...här... }.

   Tryck shift två gånger och skriv Encaps. Välj sedan "Encapsulate Fields..." (plural).

   Dubbel-skift är "search everywhere" och låter dig söka bland alla menyer och i princip alla inställningar, liksom alla klasser, metoder, fält med mera. Detta är samma som att välja Refactor | Encapsulate Fields men kan vara trevligare för den som är mer tangentbordsbunden.

   Bocka för alla fält samt avmarkera Set Access (vi vill inte skapa setters) och avmarkera även Use accessors even when field is accessible. Tryck Refactor.

1. Skapa gränssnittet Shape i paketet shapes. Som förut högerklickar vi på paketet och väljer New | Java Class, men nu väljer vi Interface i drop-down-menyn i dialogen.

2. Nu ska vi se till att Circle implementerar Shape. På class-raden lägger vi därför till implements Shape.

   Eftersom Shape ännu inte har några metoder är detta tillräckligt för tillfället.

1. Lägg till en public metod som heter draw() i Shape. Den ska inte ha några inparametrar och inte heller lämna något returvärde (vad skriver man för att indikera detta?). Som alla metoder i gränssnitt ska den också sakna "kodkropp" ({...}) och bara avslutas med semikolon.

2. Vi ser att draw() blir markerad med en varning. Det finns nämligen klasser som säger sig implementera Shape men som saknar denna metod! Motsvarande varning kan ses när man går till Circle: IDEA stryker under "public class Circle implements Shape" med röd färg.

   Placera markören någonstans i Circle där du vill ha de metoder som krävs för Shape. Tryck Alt+Insert och välj Implement Methods och sedan draw(). Då fyller IDEA i rätt metodbeskrivning.

   För enkelhets skull kommer vi inte att måla ut något än, utan bara skriva ut "innehållet" i de former som ska målas ut. Låt därför metoden skriva ut "Ritar: " + this.

   (Vad är "@Override", som IDEA genererar? Detta är en annotering som visar att detta implementerar eller override:ar en metod som är definierad längre upp i klasshierarkin. Ni får veta mer om detta under en senare föreläsning.)

3. Nu minns vi att standardutskriften för ett objekt inte var särskilt användbar. IDEA varnar till och med för detta genom att "this" blir gul ("Call to default 'toString' on 'this'").

   Använd IDEA för att generera en toString() (Alt+Insert toString()) som innehåller värdet på alla fält.

1. Alternativ 1 av 2: Lägg manuellt till metoddeklarationer för getX(), getY() och getColor() i Shape. Se till att de har samma returvärden och parametrar som i Circle, men saknar metodkropp. Vi kan ju inte implementera en fullständig getX() här uppe i Shape, eftersom gränssnittet själv inte har något x att returnera!

2. Alternativ 2: Gå till Circle. Använd Refactor | Pull Members Up. Se till att Shape är vald i den översta väljaren. Markera getX(), getY() och getColor() i medlemslistan.

   Men vad är det som ska flyttas upp? Om Shape hade varit en klass hade man kunnat välja att flytta hela implementationen av dessa metoder till Shape, om man till exempel ansåg att implementationen skulle vara samma för alla underklasser till Shape. Men nu är Shape ett gränssnitt, som inte ska innehålla någon kod – bara metodsignaturer. Därför är "Make abstract" automatiskt vald. Därmed gör IDEA en metodsignatur i Shape och låter själva implementationen finnas kvar i den ursprungliga klassen. Metoder i gränssnitt är alltid abstrakta == har ingen implementation.

   Vilken ordning metoderna hamnar i kan bero på i vilken ordning man väljer dem i listan!

   

   Välj Refactor. Detta skapar rätt metoddeklarationer i Shape och lägger också automatiskt till @Override på metoderna i Circle.

Nu har vi deklarerat att alla Shape-klasser måste ha dessa metoder.

Vi gör nu ett första test av gränssnittet och klassen tillsammans. Detta gör vi i en ny testklass.

1. Gå till CircleTest. Klona klassen med hjälp av F5. Kalla den nya klassen ShapeTest. På det sättet får ni med strukturen i det gamla testprogrammet.

2. I ShapeTest.main() ska vi inte skapa en lista av Circle, utan en lista av Shape där vi så småningom även ska kunna lägga in rektanglar och andra former.

   Vi måste också ändra loopen på motsvarande sätt, så att den plockar ut godtyckliga former och inte kräver att få cirklar.

   Variabler bör så klart också döpas om, så vi inte har en lista av former som heter "circles". Ställ markören i ett variabelnamn och välj Refactor | Rename:Shift+F6. Skriv in det nya namnet på variabeln (eller välj ett av förslagen som kommer upp) och tryck enter. IDEA byter automatiskt alla förekomster av variabelnamnet.

3. Nu bör slutet av koden se ut ungefär så här:

   	for (Shape shape : shapes) {
   	    System.out.println(shape.getX() + " " + shape.getY());
   	}

   Men nu har vi ju en riktig "ritmetod", så vi ersätter utskriftsraden med ett anrop till shape.draw().

4. Kör ShapeTest och verifiera att du får ut rätt utskrifter. Även det gamla testprogrammet CircleTest ska fortfarande fungera!

Vår nästa form är en rektangel. Även den ska implementera gränssnittet Shape.

1. Skapa klassen Rectangle med de privata fälten x, y, width, height och color. Typerna vet ni sedan tidigare.

   Ge klassen en lämplig konstruktor.

   Skapa en toString()-metod.

2. Implementera gränssnittet Shape och de metoder som krävs i detta gränssnitt.

3. Utöka testprogrammet så det också lägger några rektanglar i listan. Testa.

Vår sista form är en text. Även den ska implementera gränssnittet Shape.

1. Skapa klassen Text med de privata fälten x, y, size (storleken i punkter), color och text (en String) samt en lämplig konstruktor och toString()-metod.

2. Implementera gränssnittet Shape och de metoder som ingår i gränssnittet.

3. Utöka testprogrammet på lämpligt sätt. Testa.

1. Skapa en ny "tom" klass public abstract class AbstractShape. Se till att den implementerar Shape – alla subklasser till AbstractShape ska ju vara Shapes.

2. Byt ut implements Shape mot extends AbstractShape i klasserna Circle, Rectangle och Text. Detta innebär att klasserna blir AbstractShape, men de kommer fortfarande också att vara Shapes eftersom detta gränssnitt implementeras av AbstractShape.

3. Nu är vi redo att flytta ut vissa definitioner till den abstrakta klassen.

   Navigera till Circle och välj Refactor | Pull Members Up. Välj att medlemmar ska dras upp till AbstractShape, inte Shape. Markera fälten x,y,color, som är gemensamma för alla former. Markera även motsvarande getters. Den här gången görs metoderna inte abstrakta: Implementationen ska följa med upp.

   Vi markerar inte radius eller getRadius(), eftersom bara cirklar har radier. Inte heller draw() eller toString(): De ska visserligen finnas i alla former men behöver ha en egen implementation i varje klass.

   Vilken ordning medlemmarna och konstruktorparametrarna hamnar i kan bero på i vilken ordning man väljer dem i listan! Blir det fel kan ni göra "undo" och göra om denna refactoring.

   

   Välj Refactor. IDEA gör nu några ändringar för att koden fortfarande ska fungera.

   1. De valda fälten blir protected i AbstractShape istället för private, så att subklasser fortfarande kan komma åt dem.

   2. IDEA skapar också automatiskt en konstruktor för AbstractShape.

   3. Eftersom fälten nu är flyttade är det upp till AbstractShape att hantera initialisering av dem. Vissa tilldelningar i konstruktorn för Circle ersätts därför med anropet super(x,y,color), som vidarebefordrar parametrarna från Circle upp till AbstractShape:s konstruktor. (Ett anrop till super() ligger alltid först i en konstruktor.)

4. Tyvärr vet inte IDEA att den ska göra motsvarande ändringar i de andra klasserna.

   Navigera till Rectangle. Ta bort fälten x/y/color, ta bort motsvarande getters, och ta bort initialiseringen ur konstruktorn.

   Lägg sedan till super()-anrop motsvarande det i Circle-konstruktorn. Ta bort de tre getter-implementationer som nu blev onödiga eftersom samma kod redan ärvs ner från AbstractShape.

   Gör samma sak för Text.

Som ni märker kan det krävas lite jobb för att hålla koden i god form. Det är lätt hänt att man undviker det, men det förlorar man ofta på i det långa loppet. I projektet kommer vi att ge komplettering för duplicerad kod av den här typen.

Vi vill poängtera att vi inte införde den abstrakta klassen bara för att "spara kod", utan att det faktiskt fanns ett naturligt sammanhang mellan klasserna också: De är olika sorters former.

1. Skapa klassen Queue.

   Du kan gärna lägga den i ett nytt paket, lab3, eftersom den inte hör ihop med shapes.

2. Skapa ett privat fält List<Person> elements och initialisera detta till en ny ArrayList<>. Eftersom varje Queue har sina egna element får detta fält inte vara statiskt.

3. Det finns metoder i ArrayList som vi vill göra tillgängliga för användaren av Queue. size() är en sådan metod. Eftersom elements håller koll på antalet element den innehåller, skriver vi helt enkelt bara en size()-metod i Queue som returnerar resultatet av elements.size(). Vi delegerar alltså det egentliga arbetet till elements-listan. (IDEA kan hjälpa till – läs vidare!)

   Vi delegerar arbetet till elements även för metoderna isEmpty(), clear() och contains() på precis samma sätt, genom att ha en metod som direkt anropar och returnerar svaret från motsvarande metod i elements.

   Delegering är så pass vanligt att IDEA kan automatisera det åt oss. Genom att välja Code | Generate | Delegate Methods och sedan välja elements kan man därefter välja precis vilka metoder man vill delegera.

   I moderna versioner av Java finns relativt många metoder man skulle kunna delegera. Du behöver främst delegera size(), isEmpty(), contains(), iterator(), add(), remove(), clear(). Om du delegerar andra metoder och får problem/varningar i deklarationer som <E> och <T>, radera då helt enkelt de metoderna från den kod som skapades.

   Delegera inte metoderna equals() eller hashCode().

4. Vi behöver även några "egna" metoder. Lägg till:

   • enqueue(), som tar en person som parameter och lägger till den sist i kön, och
   • dequeue(), som hämtar personen som är först i kön, tar bort den ur kön (listan), och returnerar den.

   Dessa ska använda sig av metoderna elements.add() och elements.remove(int index) för att ta ut första elementet i elements och stoppa in ett element sist i listan.

   Tänk på att t.ex. enqueue ska lägga till ett element i en specifik kö (ett specifikt Queue-objekt), inte i kö-klassen i sin helhet. Metoderna du skriver här ska alltså inte vara statiska.

5. Nu är Queue färdig och det är dags att skapa Stack. Klasserna är lika på alla punkter utom var objekt läggs till/tas ut. Därför kan man använda IDEAs funktion clone class som man kommer åt genom att trycka F5 när markören står i klassnamnet. Ange bara namnet Stack så skapas en ny klass som ser precis ut som Queue. Byt namn på enqueue/dequeue till push/pop och ändra koden i dem så att Stack beter sig som en stack.

6. Skriv ett testprogram.

   Skapa en stack, lägg i tur och ordning in 5 olika personer i denna, och plocka sedan ut och skriv ut element i den ordning de kommer. Vi kunde använda en for-loop, men vi har egentligen inget behov av att veta vilken position vi är på – bara om det finns fler element kvar eller inte. Därför använder vi istället en while-loop som itererar så länge stacken inte är tom.

   Gör även samma sak med en kö.

7. När vi nu tar en sista titt på vad vi har gjort upptäcker vi ett par saker:

   • Stack och Queue har något gemensamt: De är en sorts listmanipulatorer som behandlar saker i listor. Då kan det kanske finnas anledning för detta att synas även i typhierarkin, genom att klasserna implementerar ett gränssnitt eller ärver från en gemensam abstrakt klass.

   • De har också en del gemensam kod, för att lagra saker i listor och vidarebefordra anrop till listor. Detta skulle man kunna flytta upp till en gemensam abstrakt klass.

   Gör detta! Skapa en superklass med något lämpligt namn, t.ex. ListManipulator. Flytta de gemensamma implementationerna dit. Här kan IDEAs Extract Superclass vara till hjälp.

   (Var detta nödvändigt? Kanske inte till 100 procent i just detta fall. Men det är bra att lära sig hitta förbättringsmöjligheter och att öva på att göra förbättringarna. I projektet är det inte ovanligt att bedömningar dras ner av strukturella problem där man t.ex. bör införa lämpliga klasser som representerar delade egenskaper.

1. Skapa equals()-metoder i AbstractShape. Använd IDEA som hjälp via Code | Generate | equals() and hashCode(): Alt+Insert. Vi är egentligen bara intresserade av equals(), men IDEA skapar också hashCode(). Denna metod används för vissa datastrukturer men är inte relevant för oss just nu.

   IDEA frågar: "Accept subclasses as parameter to equals() method?". Kryssa inte i den rutan. Vi vill bara att två objekt ska kunna anses lika om de har exakt samma klass.

   Därefter får du välja vilka fält du anser vara relevanta för att två objekt ska vara lika. Om två AbstractShape-objekt har samma koordinater men olika färg, ska de då anses vara likadana eller inte? Det avgör du själv utifrån programmets behov. Normalt anger man exakt samma fält när IDEA frågar vad som ska vara med i hashCode().

   Om det finns icke-primitiva fält, t.ex. color som är en objektpekare, kommer IDEA att fråga om de kan garanteras att inte vara null. Detta är för att inte generera onödiga null-jämförelser som kan ta någon extra nanosekund. Om du är osäker så ange att fälten kan vara null (detta kan vara något mindre effektivt men ger alltid rätt resultat).

2. Titta på de skapade equals()-metoderna. Verkar de rimliga? Man kan aldrig vara säker på att automatgenererad kod helt överensstämmer med vad man själv tänkte.

1. Vi kallar en uppsättning former för ett diagram. Skapa därför ny klass, DiagramComponent, enligt följande mönster. Detta ska bli en grafisk komponent som vet hur man ritar upp ett helt diagram på skärmen.

   import javax.swing.*;
   import java.awt.*;
   
   public class DiagramComponent extends JComponent
   {   
       @Override protected void paintComponent(final Graphics g) {
   	super.paintComponent(g);
   
   	// Senare ska vi rita upp alla former här!
       }
   }

2. Lägg till ett privat fält shapes som innehåller en lista av former.

   Skapa en konstruktor som sätter shapes till en ny lista (detta har ni gjort förr!).

   Lägg till metoden public void addShape(Shape s), som ska addera en ny form till listan.

1. Just nu har varje Shape-klass en draw()-metod, men den var ju bara en platshållare som just nu skriver ut lite text. Den metoden måste göras om för att rita med hjälp av ett Graphics-objekt. Det betyder i sin tur att metoden måste skrivas om för att få ett Graphics-objekt som parameter.

   Även här kan IDEA hjälpa till. Ställ markören i ordet draw och tryck Ctrl-F6: Refactor | Change Signature. Tryck det gröna plusset och fyll in type Graphics, name g. Det talar om att metoden ska få en ny parameter, både i Shape och i alla tre konkreta implementationer. Klicka sedan i "use any var", vilket gör att IDEA också lägger till en parameter till anropen till draw() om det finns en Graphics-variabel tillgänglig där anropet sker. Tryck sedan Refactor.

   Denna refactoring kan även användas för att byta ordning på parametrar i metoddeklaration och alla metodanrop.

   

2. Nu undrar vi om det här införde några problem. Tryck Ctrl-F9 för att kompilera. Jodå: ShapeTest fungerar inte längre, eftersom den anropar draw() utan parametrar. Vi kommer snart att testa detta i vår nya grafiska klass istället, så vi kommenterar bort anropet och kompilerar om igen.

3. Ändra implementationerna av draw() i alla tre konkreta formklasser. Kommentera bort utskrifterna och använd istället följande kodrader som ledning till hur man kan rita ut olika typer av former eller text:

       g.setColor(color);
       g.drawOval(x, y, width, height); // calc. from radius!
       g.drawRect(x, y, width, height);
       g.setFont(new Font("serif", Font.PLAIN, size));
       g.drawString(text, x, y);

4. Nu behöver vi till slut ett fönster som kan visa upp diagramkomponenten. Vi diskuterar hur detta fungerar på GUI-föreläsningarna. För tillfället nöjer vi oss med att basera koden på denna exempelkod för klassen DiagramViewer. Den slumpar fram ett antal former som visas på skärmen. Fungerar den som den är, eller behöver den justeras?

   package shapes;
   
   import javax.swing.*;
   import java.awt.*;
   import java.util.List;
   import java.util.Random;
   
   
   public class DiagramViewer
   {
       private final static List<Color> COLORS =
   	    List.of(Color.BLACK, Color.RED, Color.GREEN, Color.BLUE,
   		    Color.CYAN, Color.YELLOW, Color.MAGENTA);
   
       // Set a fixed seed 0 so you always get the same
       // shapes (for debugging)
       private final static Random rnd = new Random(0);
   
       private static Color getRandomColor() {
   	return COLORS.get(rnd.nextInt(COLORS.size()));
       }
   
       private static Circle getRandomCircle() {
   	return new Circle(rnd.nextInt(400), rnd.nextInt(400),
   			  rnd.nextInt(200), getRandomColor());
       }
   
       private static Rectangle getRandomRectangle() {
   	return new Rectangle(rnd.nextInt(400), rnd.nextInt(400),
   			     rnd.nextInt(200), rnd.nextInt(200),
   			     getRandomColor());
       }
   
       private static Text getRandomText() {
   	return new Text(rnd.nextInt(400), rnd.nextInt(400),
   			"Hello");
       }
   
       public static void main(String[] args) {
   
   	DiagramComponent comp = new DiagramComponent();
   
   	final Random rnd = new Random(0);
   
   	for (int i = 0; i < 10; i++) {
   	    switch (rnd.nextInt(3)) {
   		case 0:
   		    comp.addShape(getRandomCircle());
   		    break;
   		case 1:
   		    comp.addShape(getRandomRectangle());
   		    break;
   		case 2:
   		    comp.addShape(getRandomText());
   		    break;
   	    }
   	}
   
   	JFrame frame = new JFrame("Mitt fönster");
   	frame.setLayout(new BorderLayout());
   	frame.add(comp, BorderLayout.CENTER);
   	frame.setSize(800, 600);
   	frame.setVisible(true);
       }
   }
   

   Gör klart klassen, starta, och se ditt nya slumpmässiga konstverk!