Merge pull request iluwatar#1 from wangihzyue/master2

issue1260 change

Author: wangihzyue

compose-method/README.md

@@ -3,9 +3,9 @@ layout: pattern
 title: Compose-method
 folder: compose-method
 permalink: /patterns/compose-method/
-categories: Structural
+categories: Idiom
 tags:
- - Gang of Four
+ - Decoupling
 ---
 
 ## Intent
@@ -28,7 +28,7 @@ Wikipedia says
 
 **Programmatic Example**
 
-Refactoring to Patterns: Simplification | Compose Method | InformIT
+[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

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

@@ -1,7 +1,6 @@
 @startuml
 package com.iluwatar.composemethod {
   class AddImpl {
-    - DEFAULT_NUMBER : int {static}
     + AddImpl()
     + addPositiveNodesOriginal(head : Node) : int {static}
     + addPositiveNodesRefined(head : Node) : int {static}

compose-method/pom.xml

@@ -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

@@ -3,7 +3,10 @@
 /**
  * implement adding.
  */
-public class AddImpl {
+public class AddImpl { //NOPMD
+  /**
+   * default added number.
+   */
   private static final int DEFAULT_NUMBER = 0;
 
   /**
@@ -12,7 +15,7 @@ public class AddImpl {
    * @param head the head of the list.
    * @return the sum of positive numbers.
    */
-  public static int addPositiveNodesOriginal(Node head) {
+  public static int addPositiveNodesOriginal(final Node head) {
     Node tail = head;
     int rtn = 0;
     while (tail != null) {
@@ -34,7 +37,7 @@ public static int addPositiveNodesOriginal(Node head) {
    * @param head the head of the list.
    * @return the sum of the positive number.
    */
-  public static int addPositiveNodesRefined(Node head) {
+  public static int addPositiveNodesRefined(final Node head) {
     Node tail = head;
     int rtn = 0;
     while (nodeDetect(tail)) {
@@ -50,7 +53,7 @@ public static int addPositiveNodesRefined(Node head) {
    * @param tail the current node.
    * @return the next node of the current node.
    */
-  public static Node nextNode(Node tail) {
+  public static Node nextNode(final Node tail) {
     return tail.next;
   }
 
@@ -60,18 +63,33 @@ public static Node nextNode(Node tail) {
    * @param tail the current node.
    * @return the added result.
    */
-  public static int numberGrowth(Node tail) {
-    if (!lengthDetect(tail)) {
-      return DEFAULT_NUMBER;
+  public static int numberGrowth(final Node tail) {
+    int result;
+    if (lengthDetect(tail)) {
+      result = grow(tail.nums); //NOPMD
+    } else {
+      result = DEFAULT_NUMBER; //NOPMD
     }
-    return grow(tail.nums);
+    return result;
   }
 
-  public static boolean nodeDetect(Node tail) {
+  /**
+   * 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;
   }
 
-  public static boolean lengthDetect(Node tail) {
+  /**
+   * 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;
   }
 
@@ -81,10 +99,11 @@ public static boolean lengthDetect(Node tail) {
    * @param nums the list of numbers.
    * @return the sum of the numbers.
    */
-  public static int grow(int[] nums) {
+  public static int grow(int[] nums) { //NOPMD
     int rtn = 0;
-    for (int i = 0; i < nums.length; i++) {
-      rtn += numGrow(nums[i]);
+    for (final int x :
+            nums) {
+      rtn += numGrow(x);
     }
     return rtn;
   }
@@ -95,14 +114,23 @@ public static int grow(int[] nums) {
    * @param adder the number for judgement.
    * @return if number is positive, return it. Otherwise, return default number.
    */
-  public static int numGrow(int adder) {
+  public static int numGrow(final int adder) {
+    int result;
     if (isPositive(adder)) {
-      return adder;
+      result = adder;
+    } else {
+      result = DEFAULT_NUMBER;
     }
-    return DEFAULT_NUMBER;
+    return result;
   }
 
-  public static boolean isPositive(int a) {
-    return a > 0;
+  /**
+   * 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

@@ -1,37 +1,44 @@
 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.
- * {@link Node} is the node for list, and this term is to add the positive integer in
+ * 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 {
+public class App { //NOPMD
   /**
    * Program entry point.
    *
    * @param args command line args.
    */
-  public static void main(String[] args) {
+  public static void main(final String[] args) {
     //initialize a list.
-    Node head = new Node();
+    final var head = new Node();
     LOGGER.info("head: {}", head);
-    Random random = new Random();
-    int nodes = random.nextInt(10);
-    Node tail = 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();
+      tail.next = new Node(); //NOPMD
       tail = tail.next;
-      tail.nums = new int[random.nextInt(10)];
+      tail.nums = new int[random.nextInt(10)]; //NOPMD
       for (int j = 0; j < tail.nums.length; j++) {
         tail.nums[j] = random.nextInt(20) - 10;
       }

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

@@ -3,7 +3,13 @@
 /**
  * the data structure to create list.
  */
-public class Node {
-  int[] nums;
-  Node next;
+public class Node { //NOPMD
+  /**
+   * the list of numbers.
+   */
+  public int[] nums;
+  /**
+   * the pointer of the next node.
+   */
+  public Node next;
 }

compose-method/src/test/java/com/iluwatar/composemethod/AppTest.java

@@ -4,9 +4,16 @@
 
 import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 
-public class AppTest {
+/**
+ * Application test
+ */
+class AppTest {//NOPMD
+
   @Test
-  void shouldExecuteWithoutException() {
+  /**
+   * no exception to execute.
+   */
+  public void shouldExecuteWithoutException() {
     assertDoesNotThrow(() -> App.main(new String[]{}));
   }
 }

compose-method/src/test/java/com/iluwatar/composemethod/MethodEqualTest.java

@@ -6,12 +6,19 @@
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
-public class MethodEqualTest {
+/**
+ * to test whether the two methods are equal.
+ */
+class MethodEqualTest {//NOPMD
+
   @Test
-  void methodsEqual() {
-    Node head = new Node();
-    Random random = new Random();
-    int nodes = random.nextInt(10);
+  /**
+   * test two methods are equal.
+   */
+  public void methodsEqual() {
+    final Node head = new Node();
+    final Random random = new Random();
+    final int nodes = random.nextInt(10);
     Node tail = head;
 
     //for each node to initialize the integer list.
@@ -20,13 +27,13 @@ void methodsEqual() {
       head.nums[j] = random.nextInt(20) - 10;
     }
     for (int i = 0; i < nodes; i++) {
-      tail.next = new Node();
+      tail.next = new Node();//NOPMD
       tail = tail.next;
-      tail.nums = new int[random.nextInt(10)];
+      tail.nums = new int[random.nextInt(10)];//NOPMD
       for (int j = 0; j < tail.nums.length; j++) {
         tail.nums[j] = random.nextInt(20) - 10;
       }
     }
-    assertEquals(AddImpl.addPositiveNodesRefined(tail), AddImpl.addPositiveNodesOriginal(tail));
+    assertEquals(AddImpl.addPositiveNodesRefined(tail), AddImpl.addPositiveNodesOriginal(tail), "Two results are equals.");
   }
 }