iluwatar#1260

realize compose method pattern.

Author: wangihzyue

compose-method/README.md

@@ -0,0 +1,139 @@
+---
+layout: pattern
+title: Compose-method
+folder: compose-method
+permalink: /patterns/compose-method/
+categories: Structural
+tags:
+ - Gang of Four
+---
+
+## 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
+
+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/pom.xml

@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>java-design-patterns</artifactId>
+        <groupId>com.iluwatar</groupId>
+        <version>1.25.0-SNAPSHOT</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>compose-method</artifactId>
+    <dependencies>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-api</artifactId>
+            <version>5.4.2</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <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,108 @@
+package com.iluwatar.composemethod;
+
+/**
+ * implement adding.
+ */
+public class AddImpl {
+  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(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(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(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(Node tail) {
+    if (!lengthDetect(tail)) {
+      return DEFAULT_NUMBER;
+    }
+    return grow(tail.nums);
+  }
+
+  public static boolean nodeDetect(Node tail) {
+    return tail != null;
+  }
+
+  public static boolean lengthDetect(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) {
+    int rtn = 0;
+    for (int i = 0; i < nums.length; i++) {
+      rtn += numGrow(nums[i]);
+    }
+    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(int adder) {
+    if (isPositive(adder)) {
+      return adder;
+    }
+    return DEFAULT_NUMBER;
+  }
+
+  public static boolean isPositive(int a) {
+    return a > 0;
+  }
+}

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

@@ -0,0 +1,42 @@
+package com.iluwatar.composemethod;
+
+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
+ * each node's integer list
+ */
+@Slf4j
+public class App {
+  /**
+   * Program entry point.
+   *
+   * @param args command line args.
+   */
+  public static void main(String[] args) {
+    //initialize a list.
+    Node head = new Node();
+    LOGGER.info("head: {}", head);
+    Random random = new Random();
+    int nodes = random.nextInt(10);
+    Node tail = head;
+
+    //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 = tail.next;
+      tail.nums = new int[random.nextInt(10)];
+      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,9 @@
+package com.iluwatar.composemethod;
+
+/**
+ * the data structure to create list.
+ */
+public class Node {
+  int[] nums;
+  Node next;
+}

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

@@ -0,0 +1,12 @@
+package com.iluwatar.composemethod;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+
+public class AppTest {
+  @Test
+  void shouldExecuteWithoutException() {
+    assertDoesNotThrow(() -> App.main(new String[]{}));
+  }
+}

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

@@ -0,0 +1,32 @@
+package com.iluwatar.composemethod;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.Random;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class MethodEqualTest {
+  @Test
+  void methodsEqual() {
+    Node head = new Node();
+    Random random = new Random();
+    int nodes = random.nextInt(10);
+    Node tail = head;
+
+    //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 = tail.next;
+      tail.nums = new int[random.nextInt(10)];
+      for (int j = 0; j < tail.nums.length; j++) {
+        tail.nums[j] = random.nextInt(20) - 10;
+      }
+    }
+    assertEquals(AddImpl.addPositiveNodesRefined(tail), AddImpl.addPositiveNodesOriginal(tail));
+  }
+}