[Developer week latam] I will have to refactor ! And now ?Refactoring Techniques in Java

Transcript

1. I will have to refactor ! And now ? Kamila Santos REFACTORING TECHNIQUES IN JAVA
2. Kamila santos TECH LEAD @ZUPINNOVATION MICROSOFT MVP BOOK CO-AUTHOR, INSTRUCTOR CONTENT CREATOR @KAMILA_CODE CO-ORGANIZER @WOMAKERSCODE, @PERIFACODE AND @DEVSJAVAGIRL
3. schedule principles of refactoring when should we refactor? code smells refactoring techniques
4. What is refactoring ? We can define refactoring as a modification made to the internal structure of a software to make it simpler to understand and less costly to change, without changing its behavior.
5. Why should we refactor? Refactoring improves software design Refactoring makes software simpler to understand Improvement in the quality of blended learning Refactoring helps in finding bugs Refactoring helps us develop faster
6. Preparatory refactoring
7. Refactoring for Comprehension
8. Refactoring for garbage collection
9. Long term refactoring
10. Refactoring in Code Review
11. What are the downsides of doing refactorings? It took us longer to deliver some features Increased chance of merge conflicts Tests that need rewriting
12. Code smells Are indications of problems in the source code of a computer program. These smells could be signs of bad programming practices, poor design, or potential bugs.
13. Code smells Code smells are symptoms that code may be difficult to understand, maintain, or evolve. They are not specific errors, but rather characteristics that indicate possible underlying issues. When identified, code smells can be considered as an invitation to delve deeper into the code and make improvements.
14. Code duplication having repeating code snippets can make maintenance more difficult, as any change has to be done in multiple parts.
15. Very long methods or functions when a method or function is too long, it can make the code difficult to read and understand.
16. Class or method with many responsibilities a class or method with too many responsibilities violates the single responsibility principle, making it difficult to understand and maintain.
17. Confusing or generic variable names Variable names that are not descriptive or that don't follow naming conventions can make code difficult to understand.
18. Irrelevant or outdated comments comments that are not in line with the actual code or that don't provide useful information can be misleading and lead to errors.
19. Refactoring Techniques
20. Extract Function is used when a piece of code in a method or function can be wrapped in a separate function. This is done to improve code readability, reusability, and maintainability.
21. Extract Function you identify a block of code that performs a specific task and extract it into a new function with a descriptive name. This function encapsulates the logic contained in the original code snippet and can be called elsewhere, avoiding code duplication
24. Extract Variable is used when you have a complex expression in a piece of code that can be extracted into a variable with a descriptive name. This technique helps improve code readability, understandability, and maintainability.
25. Extract Variable you identify an expression that is difficult to understand or that is used multiple times in the code. You then extract it into a separate variable and give that variable a meaningful name.
26. Encapsulate Variable Is used to encapsulate a variable, making it private and providing access methods (getters and setters) to manipulate it. This technique helps improve the encapsulation, control, and consistency of data access.
27. Encapsulate Variable You identify a variable that is being accessed directly from outside the class and make it private. You then create accessor methods (getters) and possibly modification methods (setters) to interact with that variable.
29. Introduce Parameter Object is used when a set of related parameters is being repeatedly passed to a method or function. This technique involves creating a new object that encapsulates these related parameters, simplifying the method call and improving code readability.
30. Introduce Parameter Object you identify a set of parameters that are often passed together and group them into an object. This new object is then passed as a single parameter to the relevant method or function.
32. Split Phase is used when a method or function performs two or more distinct phases or different types of tasks. This technique involves separating these phases into separate methods or functions to improve the readability, modularity, and maintainability of the code.
33. Split Phase You identify the different phases or types of tasks being performed within a single method or function. You then extract each phase into a separate method or function, allowing each to be more focused and specific in its responsibility.
35. Extract class is used when a class contains responsibilities or functionality that can be better organized in a separate new class. This technique involves creating a new class and transferring related attributes and methods to that new class.
36. Extract class you identify a set of attributes and methods within an existing class that are related to a specific responsibility or functionality. You then extract those attributes and methods into a new class, making them more cohesive and making the code easier to maintain.
37. Remove Middle Man is used when a class acts as an unnecessary intermediary between other classes. This technique involves eliminating the middleman, allowing method calls to be made directly between the relevant classes.
38. Remove Middle Man you identify a class that is acting as a go-between, simply passing method calls to another class without adding any significant value or logic. You then direct the method calls directly to the class being brokered.
40. Hide delegate is used when a class is providing direct access to a delegate object and that direct access is being overused or violating the principle of encapsulation. This technique involves hiding the delegate object behind methods of the class that encapsulate it, limiting direct access to the delegate.
41. Hide delegate you identify the points where the class is exposing the delegate object and providing direct access to it. You then hide the delegate behind methods of the class that act as intermediaries, allowing the class to control how the delegate is accessed and preventing uncontrolled direct access.
42. Move function is applied when a function or method is located in a class that is not the best fit to contain it. This technique involves moving the function to another class that has more suitable responsibility or where the function can be more easily reused.
43. Move function And how to apply it? You should identify a function or method that is in a class where it doesn't fit well in terms of responsibility or cohesiveness. Then you move that role to a more appropriate class, ensuring the functionality is placed in the right context.
44. Remove Dead Code It is recommended when there are code snippets that are no longer used and have no impact on the program's operation. This technique involves removing these unnecessary code snippets, simplifying and making the code cleaner and more readable.
45. Remove Dead Code These snippets can include unused variables, methods or functions not called, conditional blocks that are never true or false, and so on.
46. Change Value to Reference this technique is used when we have an object that is used as a value, but we realize that it is necessary to treat it as an object with its own identity.
47. Change Value to Reference to apply this technique you must identify an object that must be treated as a single entity and not as a value. So you create a new class to represent that object, where equality is based on identity rather than object content. It then replaces occurrences of the value object with references to the new class.
49. Decompose Conditional Is used when you have a complex condition with many branches and the logic becomes difficult to understand and maintain. This technique involves breaking down the condition into smaller, clearer parts, making the code easier to understand and maintain.
50. Decompose Conditional The steps for this technique are as follows: you identify a complex condition with multiple clauses and extract each clause into a separate method or function with a descriptive name.
51. Decompose Conditional You then replace the original condition with calling those methods or functions, making the code more readable.
52. Introduce Assertions You locate a point in the code where you need to guarantee a specific condition. You then add an assertion that checks for that condition, and if the condition isn't true, an error or exception is thrown.
53. Replace Constructor with Factory Method Is applicable when you have a class with one or more constructors that can be overridden by a factory function.
54. Replace Constructor with Factory Method This technique consists of creating a static function that encapsulates object creation, providing a more expressive and flexible interface for creating instances of the class.
56. Pull up method you find a method in one or more subclasses that has a similar implementation and can be moved to the parent class.
57. Pull up method You then move that method into the parent class and adjust corresponding calls in subclasses to call the method in the parent class.
59. Extract Subclass is used when you have a class that is performing functionality that is specific to a subset of objects in that class.
60. Extract Subclass This technique involves creating a new subclass that represents that specific subset of objects and moving the relevant functionality into that new subclass.
61. Collapse Hierarchy is used when you have a hierarchy of classes where the differentiation between the subclasses becomes unnecessary or irrelevant.
62. Collapse Hierarchy you identify that the differentiation between the subclasses is no longer necessary or relevant. You then remove the intermediate subclasses and move their attributes and behaviors directly into the parent class. This simplifies the hierarchy, reduces complexity, and improves code readability.
64. Conclusion Each refactoring technique aims to solve a specific problem and many times they are even used together. There are several other techniques besides those mentioned here that can help you a lot in everyday life.
65. Do you have any questions? Hope you learned something new.