void printowing(double amount) { printbanner(); printdetails(); void printdetails(double amount) {

Transcription

1 Refactoring References: Martin Fowler, Refactoring: Improving the Design of Existing Code; ; Bruce Wampler, The Essence of Object-Oriented Oriented Programming with Java and UML A recent OO technique that has been formalized into an essential programming tool A technique to improve existing code A technique to improve design after code has been written 1 2 Principles of Refactoring Each change should be a small simple change, followed by testing. Reduces risk that refactoring will cause a problem. Easier to find the problem if it does cause a problem. Functionality remains unchanged Principles of Refactoring Disciplined changes Changes are simple and by themselves of little value. It's the cumulative effects that makes refactoring valuable. 3 4 Testing and Refactoring Build test cases first that will verify the external behavior. You don't want to change external behavior. Automated tests are important. Self-checking is important. Benefit of Refactoring Makes it easier to fix bugs and add features to code Can reveal flaws in structure of existing code that are causes of bugs 5 6 1

2 Refactoring Process When to Refactor Study the known refactorings that have been described by Fowler in Refactoring: Improving the Design of Existing Code (Addison Wesley,2000) Review code to identify refactorings Apply only one refactoring at a time reduces risk of making changes Test the program after each refactoring 7 When you plan to add functionality to the program When you find you have to add a feature to a program, and the program s code is not structured in a convenient way to add the feature, first refactor the program to make it easier to add the feature, then add the feature. [Fowler,7] Apply refactoring until design has improved enough to make it easily modifiable 8 When to Refactor Code Smells When searching for bugs During code reviews teams refactor as the group gets better understanding of the code Fowler and Kent Beck have identified smells in code that, when present, indicate you should refactor The following is a subset of their list of code smells 9 10 Code Smells Code Smells Duplicate code you need to extract some methods Long method long methods are hard to understand; extract methods Large class if a class does too much, you need to split it Long parameter list makes code hard to read consider passing objects Feature envy one class is interested in too many details of another class [Fowler] Data clumps data that is used together everywhere should be in a class of its own [Fowler]

3 Code Smells Switch statements you aren t using polymorphism effectively Inappropriate intimacy a class shouldn t know too much about any other class Data class a class needs to do something, not just maintain attributes Code Smells Refused bequest subclasses should use most of what their parents give them [Fowler] Comments a comments might be eliminated by providing a better name for a method or variable Code Smells Message chain too many messages in a chain are hard to follow [Fowler] Middleman sometimes it s better to work with an object directly [Fowler] When not to Refactor When code is beyond fixing and needs to be rewritten from scratch When program is written in a non-oo language Refactoring Categories Over 70 refactorings are described in Fowler s book Refactorings are organized into categories A sampling of the categories follows Each category includes a number of refactorings; these are in italics Composing Methods Help to reduce size of methods and make code more readable by replacing sequences of code with method calls Extract Method Inline Method Replace Temp with Query

4 Moving Features Between Objects Take responsibilities away from classes that shouldn t have them and put the responsibilities where they belong Move Method Move Field Extract Class Organizing Data Make objects from data items to clarify what the data item is being used for and to make it easier to work with Replace Data Value with Objects Replace Array with Object Simplifying Conditional Expressions Simplify complicated conditional expressions that make program hard to understand Decompose Conditional Consolidate Duplicate Conditional Fragments Replace Conditional with Polymorphism Making Method Calls Simpler Improve the interface to a class by making method names clearer and more descriptive Rename Method Add parameter Dealing with Generalization Move methods and subclasses as high up the inheritance hierarchy as possible for good object design Pull Up Method Push Down Method Extract Subclass Extract Superclass Refactorings in Detail Some refactorings with more detailed explanation and examples are discussed next

5 Extract Method When a code fragment has meaning by itself, it can be refactored as a method The method name should clearly explain the purpose of the method (this eliminates need for a comment) Duplicated code belongs in a method Extract Method Example[Fowler,110] void printowing(double amount) { printbanner(); //print details System.out.println( name: + name); System.out.println( amount + amount); void printowing(double amount) { printbanner(); printdetails(); void printdetails(double amount) { System.out.println( name: + name); System.out.println( amount + amount); Replace Temp With Query When a temporary variable is being used to hold the result of an expression, extract the expression into a method and replace all references to the temp variable with the method call Replace Temp With Query Example [Fowler,120] double baseprice = quantity * itemprice; if(baseprice > 1000) return baseprice * 0.95; else return baseprice * 0.98; if (baseprice() > 1000) return baseprice() * 0.95; else return baseprice() * 0.98; double baseprice() { return quantity * itemprice; Rename Method Rename Method Example [Fowler,274] This one is fairly obvious When the name of a method does not reveal its purpose, change the name of the method Methods should be named in a way that communicates their intention. Good naming is a skill that requires practice; improving this skill is the key to being a truly skillful programmer. [Fowler,273] 29 A method to get a person s telephone number can be defined as: public String gettelephonenumber() { return ( ( + officeareacode + ) + officenumber); Since the office number is desired, rename the method to getofficetelephonenumber 30 5

6 Rename Method Example(cont d ) Rename Method Example(end) Create the new method and copy the body over to the new method The old method changes to call the new one class Person public String gettelephonenumber() { return getofficetelephonenumber(); public String getofficetelephonenumber() { return ( ( + officeareacode + ) + officenumber); 31 Now find the callers of the old method (if client code available) and switch them to call the new one When all are switched, remove the old method If there aren t many callers, you can change callers to call the new method without first delegating the call to the old method. But the safest way is to use the delegation. 32 Pull Up Method If you have methods with identical results on subclasses, then move them to the superclass Pull Up Method Example [Fowler,324] RegularCustomer createbill(date) chargefor(start:date,end:date) Customer addbill(dat:date,amount:double) lastbilldate createbill method is identical for each class PreferredCustomer createbill(date) chargefor(start:date,end:date) void createbill(date date) { double chargeamount = chargefor(lastbilldate, date); addbill( date, charge ); Pull Up Method Example (cont d) createbill can t be moved into the superclass because chargefor is different on each subclass First have to declare it on the superclass as abstract Pull Up Method Example(result) Customer lastbilldate addbill(dat:date,amount:double) createbill(date) chargefor(start:date,end:date) class Customer... abstract double chargefor(date start, Date end) Then copy createbill from each of the subclasses, compile and test RegularCustomer chargefor(start:date,end:date) PreferredCustomer chargefor(start:date,end:date)

7 Pull Up Constructor Body You have constructors on subclasses with mostly identical bodies [Fowler,325] Can t use Pull Up Method because you can t inherit constructors Create a superclass constructor; call this from the subclass methods. [Fowler,325] Pull Up Constructor Body Example [Fowler,326] class Employee... protected String _name; protected String _id; class Manager extends Employee... public Manager(String name, String id, int grade){ _name = name; _id = id; _grade = grade; private int _grade; Define a constructor for Employee that can be called by a Manager object Pull Up Constructor Body Example class Employee... protected String _name; protected String _id; protected Employee (String name, String id) { _name = name; _id = id; class Manager... public Manager (String name, String id, int grade) { super (name, id); _grade = grade; Replace Conditional With Polymorphism You have a conditional that chooses different behavior depending on the type of an object. Move each leg of the conditional to an overriding method in a subclass. Make the original method abstract. [Fowler,255] Must have inheritance structure already in place Replace Conditional With Polymorphism double getspeed() { switch (_type) { case EUROPEAN: return getbasespeed(); case AFRICAN: return getbasespeed() - getloadfactor() * _numberofcoconuts; case NORWEGIAN_BLUE: return(_isnailed)? 0 : getbasespeed(_voltage); throw new RuntimeException( Should be reachable ); //[Fowler,255] Replace Conditional With Polymorphism European getspeed() Bird getspeed() NorwegianBlue getspeed() African getspeed() Three subclasses of Bird are created from the conditional. Each overrides the getspeed() method

8 Replace Conditional With Polymorphism Bad idea to do a switch based on attribute of another object If using a switch, it should be on your own data, not another object s Example of this on next slide 43 Replace Conditional With Polymorphism class Rental double { Indicates that getcharge double result = 0; should move into Movie switch(getmovie().getpricecode() ())) { case Movie.REGULAR: result += 2; if(getdaysrented() () > 2) result += (getdaysrented() - 2) * 1.5; case Movie.NEW_RELEASE: result += getdaysrented() * 3; case Movie.CHILDRENS: result += 1.5; if (getdaysrented() > 3) result += (getdaysrented() getdaysrented()-3) * 1.5; return result; 44 Replace Conditional With Polymorphism Replace Conditional With Polymorphism class Movie double getcharge(int daysrented) { double result = 0; switch(getpricecode() ())) { case Movie.REGULAR: result += 2; if(daysrented() > 2) result += (daysrented() case Movie.NEW_RELEASE: Now querying our own data () - 2) * 1.5; result += daysrented() * 3; case Movie.CHILDRENS: result += 1.5; if (daysrented() > 3) result += (daysrented() daysrented()-3) * 1.5; return result; 45 Next compile the method into Movie and then change the getcharge on rental to use the new method class Rental... double getcharge() { return _movie.getcharge(daysrented); 46 Replace Conditional With Polymorphism Several types of movies have different ways of answering the same question This is a job for subclasses Each subclass of Movie has its own version of charge (ie regular, children s, new releases, etc.) Replace Conditional With Polymorphism RegularMovie Movie ChildrensMovie NewReleaseMovie Still need one more change. A movie can change classification during its lifetime. An object cannot change its class during its lifetime. Therefore, need the State pattern [GoF]

9 Replace Conditional With Polymorphism : Using State Pattern Encapsulate the state-specific specific behavior into separate objects and have the context delegatestate-specific specific requests to these objects. Using the State Pattern on Movie Movie RegularPrice 1 Price ChildrensPrice NewReleasePrice return price. Subclassing is done from price code object. Price can be changed whenever necessary Replace Conditional With Polymorphism : Motivation Biggest gain from polymorphism occurs when same set of conditions appears many places in the program To add a new type, you have to find and update all the conditionals But with subclasses you simply create a new subclass and provide the appropriate methods Clients of the class don t need to know about the subclasses, which reduces the coupling in your system [Fowler,256] 51 Decompose Conditional You have a complicated conditional (if- then-else) else) statement. Extract methods from the condition, then part, and else parts. [Fowler,238] Highlight the condition and make clear what you re branching on, and highlight reason for branching. 52 Decompose Conditional Decompose Conditional if ( date.before (SUMMER_START) date.after (SUMMER_END) ) charge = quantity * _winterrate + _winterservicecharge; else charge = quantity * _summerrate; if ( notsummer ( date ) ) charge = wintercharge ( quantity ); else charge = summercharge ( quantity ); Example continued: private boolean notsummer( Date date ) { return date.before (SUMMER_START) date.after (SUMMER_END); private double summercharge (int quantity) { return quantity * _summerrate; private double wintercharge (int quantity) { return quantity * _winterrate + _winterservicecharge; 53 Each extraction should be done separately, then compiled & tested 54 9

10 Consolidate Conditional Expression You have a sequence of conditional tests with the same result. Combine them into a single conditional expression and extract it. [Fowler,240] Makes check clearer Replaces statement of what you re doing with why you re doing it. Must first make sure none of the conditionals has side effects. Consolidate Conditional Expression double disabilityamount () { if (_seniority < 2 ) return 0; if (_monthsdisabled > 12 ) return 0; if (_isparttime) return 0; //compute disability amount double disabilityamount () { if (isnoteligiblefordisability () ) return 0; //compute disability amount Consolidate Conditional Expression if (onvacation() ) if (lengthofservice () > 10 ) return 1; return 0.5; if (onvacation () && length)fservice () > 10 ) return 1; else return 0.5; return (onvacation () && lengthof Service () > 10? 1 : 0.5; 57 10