iluwatar#1260

Author: wangihzyue

compose-method/README.md

@@ -0,0 +1,139 @@
+---
+layout: pattern
+title: Compose-method
+folder: compose-method
+permalink: /patterns/compose-method/
+categories: Idiom
+tags:
+ - Decoupling
+---
+
+## Intent
+
+Transform the logic into a small number of intention-revealing steps at the same level of detail.
+
+## Explanation
+
+Real world example
+
+> to make the method easy to read.
+
+In plain words
+
+> Composed Method is a small, simple method that you can understand in seconds.
+
+Wikipedia says
+
+> In software engineering, composed method is to divide your program into methods that perform one identifiable task. Keep all of the operations in a method at the same level of abstraction. This will naturally result in programs with many small methods, each a few lines long.
+
+**Programmatic Example**
+
+[Refactoring to Patterns: Simplification | Compose Method | InformIT](https://www.informit.com/articles/article.aspx?p=1398607)
+
+The original method is relative hard to understand the meaning. 
+```java
+public class List{
+    public void  add(Object element){
+        if(!readOnly){
+            int newSize = size + 1;
+            if (newSize > elements.length) {
+                Object[] newElements =
+                        new Object[elements.length + 10];
+                for (int i = 0; i < size; i++)
+                    newElements[i] = elements[i];
+                elements = newElements;
+            }
+            elements[size++] = element;
+        }
+    }
+}
+```
+
+After use a guard clause, we can make an early exit from the method.
+
+```java
+public class List{
+    public void add(Object element) {
+        if (readOnly)
+            return;
+        int newSize = size + 1;
+        if (newSize > elements.length) {
+            Object[] newElements =
+                    new Object[elements.length + 10];
+            for (int i = 0; i < size; i++)
+                newElements[i] = elements[i];
+            elements = newElements;
+        }
+        elements[size++] = element;
+    }
+}
+```
+
+change the constant to be more communicative.
+
+```java
+public class List{
+    private final static int GROWTH_INCREMENT = 10;
+    
+    public void add(Object element) {
+        if (readOnly)
+            return;
+        int newSize = size + 1;
+        if (newSize > elements.length) {
+            Object[] newElements =
+                    new Object[elements.length + GROWTH_INCREMENT];
+            for (int i = 0; i < size; i++)
+                newElements[i] = elements[i];
+            elements = newElements;
+        }
+        elements[size++] = element;
+    }
+}
+```
+
+Finally, extract each part of the code as the methods.
+
+```java
+public class List{
+    private final static int GROWTH_INCREMENT = 10;
+
+    public void add(Object element) {
+        if (readOnly)
+            return;
+        if (atCapacity())
+            grow();
+        addElement(element);
+    }
+
+    private boolean atCapacity() {
+        return (size + 1) > elements.length;
+    }
+
+    private void grow() {
+        Object[] newElements =
+                new Object[elements.length + GROWTH_INCREMENT];
+        for (int i = 0; i < size; i++)
+            newElements[i] = elements[i];
+        elements = newElements;
+    }
+
+    private void addElement(Object element) {
+        elements[size++] = element;
+    }
+}
+```
+
+## Applicability
+
+Use the Compose method pattern when
+
+* You want to make the content of the method easy to read.
+* You want to set each method with one function.
+
+## Real world examples
+
+* [java.awt.Container](http://docs.oracle.com/javase/8/docs/api/java/awt/Container.html) and [java.awt.Component](http://docs.oracle.com/javase/8/docs/api/java/awt/Component.html)
+
+## Credits
+
+* [Refactoring to Patterns: Simplification](https://www.informit.com/articles/article.aspx?p=1398607)

compose-method/etc/compose-method.urm.puml

@@ -0,0 +1,27 @@
+@startuml
+package com.iluwatar.composemethod {
+  class AddImpl {
+    + AddImpl()
+    + addPositiveNodesOriginal(head : Node) : int {static}
+    + addPositiveNodesRefined(head : Node) : int {static}
+    + grow(nums : int[]) : int {static}
+    + isPositive(a : int) : boolean {static}
+    + lengthDetect(tail : Node) : boolean {static}
+    + nextNode(tail : Node) : Node {static}
+    + nodeDetect(tail : Node) : boolean {static}
+    + numGrow(adder : int) : int {static}
+    + numberGrowth(tail : Node) : int {static}
+  }
+  class App {
+    - LOGGER : Logger {static}
+    + App()
+    + main(args : String[]) {static}
+  }
+  class Node {
+    ~ next : Node
+    ~ nums : int[]
+    + Node()
+  }
+}
+Node -->  "-next" Node
+@enduml

facet/pom.xml renamed to compose-method/pom.xml

@@ -9,7 +9,7 @@
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
-    <artifactId>facet</artifactId>
+    <artifactId>compose-method</artifactId>
     <dependencies>
         <dependency>
             <groupId>org.junit.jupiter</groupId>
@@ -27,9 +27,5 @@
             </plugin>
         </plugins>
     </build>
-    <properties>
-        <maven.compiler.source>11</maven.compiler.source>
-        <maven.compiler.target>11</maven.compiler.target>
-    </properties>
 
 </project>

compose-method/src/main/java/com/iluwatar/composemethod/AddImpl.java

@@ -0,0 +1,136 @@
+package com.iluwatar.composemethod;
+
+/**
+ * implement adding.
+ */
+public class AddImpl { //NOPMD
+  /**
+   * default added number.
+   */
+  private static final int DEFAULT_NUMBER = 0;
+
+  /**
+   * original add method.
+   *
+   * @param head the head of the list.
+   * @return the sum of positive numbers.
+   */
+  public static int addPositiveNodesOriginal(final Node head) {
+    Node tail = head;
+    int rtn = 0;
+    while (tail != null) {
+      if (tail.nums.length > 0) {
+        for (int i = 0; i < tail.nums.length; i++) {
+          if (tail.nums[i] > 0) {
+            rtn += tail.nums[i];
+          }
+        }
+      }
+      tail = tail.next;
+    }
+    return rtn;
+  }
+
+  /**
+   * refined adding method.
+   *
+   * @param head the head of the list.
+   * @return the sum of the positive number.
+   */
+  public static int addPositiveNodesRefined(final Node head) {
+    Node tail = head;
+    int rtn = 0;
+    while (nodeDetect(tail)) {
+      rtn += numberGrowth(tail);
+      tail = nextNode(tail);
+    }
+    return rtn;
+  }
+
+  /**
+   * point to the next node of the current node.
+   *
+   * @param tail the current node.
+   * @return the next node of the current node.
+   */
+  public static Node nextNode(final Node tail) {
+    return tail.next;
+  }
+
+  /**
+   * add a list of positive number or skip when the list is empty.
+   *
+   * @param tail the current node.
+   * @return the added result.
+   */
+  public static int numberGrowth(final Node tail) {
+    int result;
+    if (lengthDetect(tail)) {
+      result = grow(tail.nums); //NOPMD
+    } else {
+      result = DEFAULT_NUMBER; //NOPMD
+    }
+    return result;
+  }
+
+  /**
+   * check whether the node is null.
+   *
+   * @param tail current node.
+   * @return whether it is null.
+   */
+  public static boolean nodeDetect(final Node tail) {
+    return tail != null;
+  }
+
+  /**
+   * check the length of list is positive.
+   *
+   * @param tail the current node.
+   * @return whether its list is positive.
+   */
+  public static boolean lengthDetect(final Node tail) {
+    return tail.nums.length > 0;
+  }
+
+  /**
+   * compute the total sum of the list of positive numbers.
+   *
+   * @param nums the list of numbers.
+   * @return the sum of the numbers.
+   */
+  public static int grow(int[] nums) { //NOPMD
+    int rtn = 0;
+    for (final int x :
+            nums) {
+      rtn += numGrow(x);
+    }
+    return rtn;
+  }
+
+  /**
+   * judge whether the number is positive.
+   *
+   * @param adder the number for judgement.
+   * @return if number is positive, return it. Otherwise, return default number.
+   */
+  public static int numGrow(final int adder) {
+    int result;
+    if (isPositive(adder)) {
+      result = adder;
+    } else {
+      result = DEFAULT_NUMBER;
+    }
+    return result;
+  }
+
+  /**
+   * check the number is positive.
+   *
+   * @param adder the number.
+   * @return whethr is positive.
+   */
+  public static boolean isPositive(final int adder) {
+    return adder > 0;
+  }
+}

compose-method/src/main/java/com/iluwatar/composemethod/App.java

@@ -0,0 +1,49 @@
+package com.iluwatar.composemethod;
+
+import java.security.SecureRandom;
+import java.util.Random;
+import lombok.extern.slf4j.Slf4j;
+
+/**
+ * add original method is rough, and the new
+ * add method is using the composed method.
+ * In this example, refactor the method to
+ * let each method contain only one function
+ * and ensure the refactored method's result
+ * is equals to the original method.
+ * {@link Node} is the node for list, and
+ * this term is to add the positive integer in
+ * each node's integer list
+ */
+@Slf4j
+public class App { //NOPMD
+  /**
+   * Program entry point.
+   *
+   * @param args command line args.
+   */
+  public static void main(final String[] args) {
+    //initialize a list.
+    final var head = new Node();
+    LOGGER.info("head: {}", head);
+    final SecureRandom random = new SecureRandom();
+    final int nodes = random.nextInt(10);
+    var tail = head; //NOPMD
+
+    //for each node to initialize the integer list.
+    head.nums = new int[random.nextInt(10)];
+    for (int j = 0; j < head.nums.length; j++) {
+      head.nums[j] = random.nextInt(20) - 10;
+    }
+    for (int i = 0; i < nodes; i++) {
+      tail.next = new Node(); //NOPMD
+      tail = tail.next;
+      tail.nums = new int[random.nextInt(10)]; //NOPMD
+      for (int j = 0; j < tail.nums.length; j++) {
+        tail.nums[j] = random.nextInt(20) - 10;
+      }
+    }
+    LOGGER.info("original method result: {}", AddImpl.addPositiveNodesOriginal(head));
+    LOGGER.info("refined method result: {}", AddImpl.addPositiveNodesRefined(head));
+  }
+}

compose-method/src/main/java/com/iluwatar/composemethod/Node.java

@@ -0,0 +1,15 @@
+package com.iluwatar.composemethod;
+
+/**
+ * the data structure to create list.
+ */
+public class Node { //NOPMD
+  /**
+   * the list of numbers.
+   */
+  public int[] nums;
+  /**
+   * the pointer of the next node.
+   */
+  public Node next;
+}