Hugbúnaðarverkefni 2 - Static Analysis

Transcription

1 Time to do some refactoring of my Java. Hugbúnaðarverkefni 2 - Static Analysis Fyrirlestrar 7 & 8 A Refactoring Micro-Example 15/01/2006 Dr Andy Brooks 1

2 Case Study Dæmisaga Reference A Refactoring Micro-Example, David Parsons, (broken link 8 september 2005) 15/01/2006 Dr Andy Brooks 2

3 What is refactoring? Refactoring is the process of improving the design of existing code without changing its observable behaviour. It is an ongoing process of continual cleanup. Dave Parsons There is a dedicated website: 15/01/2006 Dr Andy Brooks 3

4 Replace smelly code Signs of decay include: Duplicated code Switch statements Long methods Large classes Data classes (only getters and setters in the API) Long parameter lists Use of primitives rather than objects Temporary variables and fields When you write smelly code you are hacking... 15/01/2006 Dr Andy Brooks 4

5 Test the changes Every refactoring change should be tested. Recompile and test after every change. If we want to refactor, the essential precondition is having solid tests. Martin Fowler 15/01/2006 Dr Andy Brooks 5

6 Fowler s Rule of Three The first time you write something you just do it. The second time, you wince at the duplication. The third time, you refactor. Two hats rule R D Do not try to develop code at the same time as you refactor code. Refactor while you wear your refactoring hat: do not develop. 15/01/2006 Dr Andy Brooks 6

7 The micro example A method of some dice game class that throws a couple of dice and returns a result. dice is an array of Die. public int getscore() { int result; result = (int)(math.random() * 6) + 1; dice[0].setfacevalue(result); result = (int)(math.random() * 6) + 1; dice[1].setfacevalue(result); } 0<=x<1 1<=x<7 (int) truncates fraction int score = dice[0].getfacevalue() + dice[1].getfacevalue(); return score; 15/01/2006 Dr Andy Brooks 7

8 Refactoring 1 Self Encapsulate Field Use accessor methods, do not directly access an object s fields within its methods. public int getscore() The underlying representation of { a die can be changed. int result; result = (int)(math.random() * 6) + 1; getdice(0).setfacevalue(result); result = (int)(math.random() * 6) + 1; getdice(1).setfacevalue(result); int score =getdice(0).getfacevalue() +getdice(1).getfacevalue(); return score; } 15/01/2006 Dr Andy Brooks 8

9 Refactoring 2 Extract Method Split up a longer method into smaller methods. public int getscore() { int result; result = rolldie(); getdice(0).setfacevalue(result); result = rolldie(); getdice(1).setfacevalue(result); int score = getdice(0).getfacevalue() + getdice(1).getfacevalue(); return score; } public int rolldie() { return (int)(math.random() * 6) + 1; } 15/01/2006 Dr Andy Brooks 9

10 Refactoring 3 Rename class/method/field Change names to be more meaningful. public int throwdice() { int result; result = rolldie(); getdice(0).setfacevalue(result); result = rolldie(); getdice(1).setfacevalue(result); int score = getdice(0).getfacevalue() + getdice(1).getfacevalue(); return score; } public int rolldie() { return (int)(math.random() * 6) + 1; } 15/01/2006 Dr Andy Brooks 10

11 Refactoring 4 Replace Temp with Query Use a query method instead of a temporary variable. public int throwdice() { int result; result = rolldie(); getdice(0).setfacevalue(result); result = rolldie(); getdice(1).setfacevalue(result); return getdicevalue();} public int rolldie() { return (int)(math.random() * 6) + 1;} int getdicevalue() { return getdice(0).getfacevalue() + getdice(1).getfacevalue();} 15/01/2006 Dr Andy Brooks 11

12 Refactoring 5 Move Method Dice objects are data objects. It would be better to move the rolldie() method to the Dice class and have this method set the state of the object. The rolldie() method can also be renamed to roll(). public void roll() { setfacevalue((int)(math.random() * 6) + 1); } 15/01/2006 Dr Andy Brooks 12

13 Refactoring 5 Move Method public int throwdice() { getdice(0).roll(); getdice(1).roll(); return getdicevalue(); } The code is beginning to look much cleaner. int getdicevalue() { return getdice(0).getfacevalue() + getdice(1).getfacevalue(); } 15/01/2006 Dr Andy Brooks 13

14 Refactor 6 Replace conditional with polymorphism Switch statements that depend on the type of an object should be replaced with class hierarchies and polymorphic methods. Suppose the Die class had code to model two kinds of dice: NORMAL or LOADED. static final int NORMAL = 1; static final int LOADED = 2; private int type; 15/01/2006 Dr Andy Brooks 14

15 Refactor 6 Replace conditional with polymorphism public void roll() The roll() method now has a switch. { switch(gettype()) { case NORMAL: setfacevalue((int)(math.random() * 6) + 1); break; case LOADED: // random is a static java.util.random object easier // to fix a range of integers (2 6) than Math.random setfacevalue(random.nextint(5) + 2); break; default: setfacevalue(1); inclusive of 0 } exclusive of 5 } 15/01/2006 Dr Andy Brooks 15

16 Refactor 6 Replace conditional with polymorphism Die abstract superclass Normal Loaded //Normal Die implementation public void roll() { setfacevalue((int)(math.random() * 6) + 1); } //Loaded Die implementation public void roll() { setfacevalue(random.nextint(5) + 2); } 15/01/2006 Dr Andy Brooks 16

17 Refactor 7 Replace Magic Number with Symbolic Constant public static final int MAX_RANDOM = 6; public static final int MIN_DICE_VALUE = 2; public void roll() { setfacevalue(random.nextint(max_random - 1) + MIN_DICE_VALUE); } 6 rather than 5 because we want to express the maximum value of a die. 15/01/2006 Dr Andy Brooks 17

18 Replace indexed access with iteration? public int throwdice() { getdice(0).roll(); getdice(1).roll(); return getdicevalue(); } The real question is: do we need indexed access if we just have two die objects? The answer is no. We will never need to be able to use a different number of dice. The use of an array or collection provides too much functionality. We just need two named die objects: getfirstdie().roll(); getseconddie().roll(); indexed access 15/01/2006 Dr Andy Brooks 18

19 Replace polymorphism with parameterised algorithm Do we really need to use inheritance and have a polymorphic roll() method? No. We could make use of a parameterised method. If you have two algorithms that do something similar, consider if they can be combined into a single algorithm in a parameterised method. int getrandomint(int min, int max); 15/01/2006 Dr Andy Brooks 19

20 Knowing that we will only ever have two die and recognising that a parameterised method can be used to model a normal and loaded die... completely changes the look of the code... 15/01/2006 Dr Andy Brooks 20

21 Reflections Were the refactorings carried out in the right order? Can refactorings be prioritised? Should refactoring first consider core architectural issues? Should we start with the simplest refactorings? 15/01/2006 Dr Andy Brooks 21

22 Reflections Refactorings are often reversible. Replace Inheritance with Delegation and Replace Delegation with Inheritance. We may do a refactoring only to undo it. A tool providing a direct link between software metric scores and suggested refactorings would be very useful. 15/01/2006 Dr Andy Brooks 22

23 Some refactoring examples explained with the help of UML. 15/01/2006 Dr Andy Brooks 23

24 Pull Up Field Eliminating duplicate fields can help reduce defects and allows methods that use the fields to be moved to the superclass. 15/01/2006 Dr Andy Brooks 24

25 Push Down Field Push a field down if it is not needed in the superclass. 15/01/2006 Dr Andy Brooks 25

26 Pull Up Method Eliminating duplicate methods can help reduce defects. 15/01/2006 Dr Andy Brooks 26

27 Push Down Method Methods should be pushed down if the they are not used by all the subclasses. 15/01/2006 Dr Andy Brooks 27

28 Replace inheritance with delegation class Sub extends Super {...} Suppose an object of Sub never uses the methods ying() and yang(). Class Sub should then not inherit from class Super. 15/01/2006 Dr Andy Brooks 28

29 Replace inheritance with delegation class Sub { Super s = new Super(); int foo() { return s.foo(); } void bar() { s.bar(); } int baz() {...} } // delegation // delegation // new method 15/01/2006 Dr Andy Brooks 29

30 Replace delegation with inheritance class Sub { Super s = new Super(); int foo() { return s.foo(); } // delegation void bar() { s.bar(); } // delegation char ying() {return s.ying();} // delegation char yang() {return s.yang();} // delegation int baz() {...} // new method } 15/01/2006 Dr Andy Brooks 30

31 Replace delegation with inheritance Suppose an object of Sub uses all of the methods foo(), bar(), ying() and yang(). Class Sub should then inherit from class Super. class Sub extends Super {...} 15/01/2006 Dr Andy Brooks 31

32 Hide Delegate Hide a delegate class (Department) by creating a method on the server (Person). manager = andy.getdepartment().getmanager(); manager = andy.getmanager(); 32

33 Remove Middle Man The server class (Person) is delegating too much, so have the client call the delegate class (Department) directly. manager = andy.getmanager(); manager = andy.getdepartment().getmanager(); 33

34 Hide Delegate and Remove Middle Man: Which refactoring is appropriate depends on the number of delegating methods involved (such as getmanager()). If there are a lot of delegating methods then the client should access the delegated class directly. 15/01/2006 Dr Andy Brooks 34

35 Hide Method If a method is not used by any other class make the visibility private. 15/01/2006 Dr Andy Brooks 35

36 Do no forget the Two Hats Rule. Refactor code in the context of a testing framework. Each change has to be tested. Do not forget many refactorings come in pairs. A refactoring may be reversed at a later date. The part played by data members can influence a refactoring decision. There are many more recognised refactorings. 15/01/2006 Dr Andy Brooks 36