Resolves checkstyle errors for remaining m (#1090)

* Reduces checkstyle errors in marker

* Reduces checkstyle errors in master-worker-pattern

* Reduces checkstyle errors in mediator

* Reduces checkstyle errors in memento

* Reduces checkstyle errors in model-view-controller

* Reduces checkstyle errors in model-view-presenter

* Reduces checkstyle errors in module

* Reduces checkstyle errors in monad

* Reduces checkstyle errors in monostate

* Reduces checkstyle errors in multiton

* Reduces checkstyle errors in mute-idiom

* Reduces checkstyle errors in mutex

Author: anuragagarwal561994

marker/src/main/java/App.java

@@ -25,27 +25,23 @@
 import org.slf4j.LoggerFactory;
 
 /**
- * Created by Alexis on 28-Apr-17.
- * With Marker interface idea is to make empty interface and extend it.
- * Basically it is just to identify the special objects from normal objects.
- * Like in case of serialization , objects that need to be serialized must implement serializable interface
- * (it is empty interface) and down the line writeObject() method must be checking
- * if it is a instance of serializable or not.
- * <p>
- * Marker interface vs annotation
- * Marker interfaces and marker annotations both have their uses,
- * neither of them is obsolete or always better then the other one.
- * If you want to define a type that does not have any new methods associated with it,
- * a marker interface is the way to go.
- * If you want to mark program elements other than classes and interfaces,
- * to allow for the possibility of adding more information to the marker in the future,
- * or to fit the marker into a framework that already makes heavy use of annotation types,
- * then a marker annotation is the correct choice
+ * Created by Alexis on 28-Apr-17. With Marker interface idea is to make empty interface and extend
+ * it. Basically it is just to identify the special objects from normal objects. Like in case of
+ * serialization , objects that need to be serialized must implement serializable interface (it is
+ * empty interface) and down the line writeObject() method must be checking if it is a instance of
+ * serializable or not.
+ *
+ * <p>Marker interface vs annotation Marker interfaces and marker annotations both have their uses,
+ * neither of them is obsolete or always better then the other one. If you want to define a type
+ * that does not have any new methods associated with it, a marker interface is the way to go. If
+ * you want to mark program elements other than classes and interfaces, to allow for the possibility
+ * of adding more information to the marker in the future, or to fit the marker into a framework
+ * that already makes heavy use of annotation types, then a marker annotation is the correct choice
  */
 public class App {
 
   /**
-   * Program entry point
+   * Program entry point.
    *
    * @param args command line args
    */

marker/src/main/java/Guard.java

@@ -25,7 +25,7 @@
 import org.slf4j.LoggerFactory;
 
 /**
- * Class defining Guard
+ * Class defining Guard.
  */
 public class Guard implements Permission {
 

marker/src/main/java/Permission.java

@@ -22,8 +22,7 @@
  */
 
 /**
- * Interface without any methods
- * Marker interface is based on that assumption
+ * Interface without any methods Marker interface is based on that assumption.
  */
 public interface Permission {
 }

marker/src/main/java/Thief.java

@@ -25,7 +25,7 @@
 import org.slf4j.LoggerFactory;
 
 /**
- * Class defining Thief
+ * Class defining Thief.
  */
 public class Thief {
 

master-worker-pattern/src/main/java/com/iluwatar/masterworker/App.java

@@ -28,40 +28,47 @@
 import org.slf4j.LoggerFactory;
 
 /**
- * <p>The <b><em>Master-Worker</em></b> pattern is used when the problem at hand can be solved by dividing into 
- * multiple parts which need to go through the same computation and may need to be aggregated to get final result.
- * Parallel processing is performed using a system consisting of a master and some number of workers, where a 
- * master divides the work among the workers, gets the result back from them and assimilates all the results to
- * give final result. The only communication is between the master and the worker - none of the workers communicate
- * among one another and the user only communicates with the master to get required job done.</p>
- * <p>In our example, we have generic abstract classes {@link MasterWorker}, {@link Master} and {@link Worker} which
- * have to be extended by the classes which will perform the specific job at hand (in this case finding transpose of
- * matrix, done by {@link ArrayTransposeMasterWorker}, {@link ArrayTransposeMaster} and {@link ArrayTransposeWorker}).
- * The Master class divides the work into parts to be given to the workers, collects the results from the workers and
- * aggregates it when all workers have responded before returning the solution. The Worker class extends the Thread
- * class to enable parallel processing, and does the work once the data has been received from the Master. The
- * MasterWorker contains a reference to the Master class, gets the input from the App and passes it on to the Master.
- * These 3 classes define the system which computes the result. We also have 2 abstract classes {@link Input} and
- * {@link Result}, which contain the input data and result data respectively. The Input class also has an abstract
- * method divideData which defines how the data is to be divided into segments. These classes are extended by
- * {@link ArrayInput} and {@link ArrayResult}.</p>
+ * <p>The <b><em>Master-Worker</em></b> pattern is used when the problem at hand can be solved by
+ * dividing into
+ * multiple parts which need to go through the same computation and may need to be aggregated to get
+ * final result. Parallel processing is performed using a system consisting of a master and some
+ * number of workers, where a master divides the work among the workers, gets the result back from
+ * them and assimilates all the results to give final result. The only communication is between the
+ * master and the worker - none of the workers communicate among one another and the user only
+ * communicates with the master to get required job done.</p>
+ * <p>In our example, we have generic abstract classes {@link MasterWorker}, {@link Master} and
+ * {@link Worker} which
+ * have to be extended by the classes which will perform the specific job at hand (in this case
+ * finding transpose of matrix, done by {@link ArrayTransposeMasterWorker}, {@link
+ * ArrayTransposeMaster} and {@link ArrayTransposeWorker}). The Master class divides the work into
+ * parts to be given to the workers, collects the results from the workers and aggregates it when
+ * all workers have responded before returning the solution. The Worker class extends the Thread
+ * class to enable parallel processing, and does the work once the data has been received from the
+ * Master. The MasterWorker contains a reference to the Master class, gets the input from the App
+ * and passes it on to the Master. These 3 classes define the system which computes the result. We
+ * also have 2 abstract classes {@link Input} and {@link Result}, which contain the input data and
+ * result data respectively. The Input class also has an abstract method divideData which defines
+ * how the data is to be divided into segments. These classes are extended by {@link ArrayInput} and
+ * {@link ArrayResult}.</p>
  */
 
 public class App {
 
   private static final Logger LOGGER = LoggerFactory.getLogger(App.class);
+
   /**
    * Program entry point.
+   *
    * @param args command line args
    */
 
   public static void main(String[] args) {
     ArrayTransposeMasterWorker mw = new ArrayTransposeMasterWorker();
     int rows = 10;
     int columns = 20;
-    int[][] inputMatrix = ArrayUtilityMethods.createRandomIntMatrix(rows,columns);    
+    int[][] inputMatrix = ArrayUtilityMethods.createRandomIntMatrix(rows, columns);
     ArrayInput input = new ArrayInput(inputMatrix);
-    ArrayResult result = (ArrayResult) mw.getResult(input);    
+    ArrayResult result = (ArrayResult) mw.getResult(input);
     if (result != null) {
       ArrayUtilityMethods.printMatrix(inputMatrix);
       ArrayUtilityMethods.printMatrix(result.data);

master-worker-pattern/src/main/java/com/iluwatar/masterworker/ArrayInput.java

@@ -27,16 +27,15 @@
 import java.util.Arrays;
 
 /**
- *Class ArrayInput extends abstract class {@link Input} and contains data
- *of type int[][].
+ * Class ArrayInput extends abstract class {@link Input} and contains data of type int[][].
  */
 
 public class ArrayInput extends Input<int[][]> {
 
   public ArrayInput(int[][] data) {
     super(data);
   }
-  
+
   static int[] makeDivisions(int[][] data, int num) {
     int initialDivision = data.length / num; //equally dividing
     int[] divisions = new int[num];
@@ -81,6 +80,6 @@ public ArrayList<Input> divideData(int num) {
         }
       }
       return result;
-    }    
-  } 
+    }
+  }
 }

master-worker-pattern/src/main/java/com/iluwatar/masterworker/ArrayResult.java

@@ -24,8 +24,7 @@
 package com.iluwatar.masterworker;
 
 /**
- *Class ArrayResult extends abstract class {@link Result} and contains data
- *of type int[][].
+ * Class ArrayResult extends abstract class {@link Result} and contains data of type int[][].
  */
 
 public class ArrayResult extends Result<int[][]> {

master-worker-pattern/src/main/java/com/iluwatar/masterworker/ArrayUtilityMethods.java

@@ -23,23 +23,23 @@
 
 package com.iluwatar.masterworker;
 
+import java.util.Random;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.util.Random;
-
 /**
- *Class ArrayUtilityMethods has some utility methods for matrices and arrays.
+ * Class ArrayUtilityMethods has some utility methods for matrices and arrays.
  */
 
 public class ArrayUtilityMethods {
 
   private static final Logger LOGGER = LoggerFactory.getLogger(ArrayUtilityMethods.class);
-  
+
   private static final Random RANDOM = new Random();
+
   /**
-   * Method arraysSame compares 2 arrays @param a1 and @param a2
-   * and @return whether their values are equal (boolean).
+   * Method arraysSame compares 2 arrays @param a1 and @param a2 and @return whether their values
+   * are equal (boolean).
    */
 
   public static boolean arraysSame(int[] a1, int[] a2) {
@@ -61,10 +61,10 @@ public static boolean arraysSame(int[] a1, int[] a2) {
   }
 
   /**
-   * Method matricesSame compares 2 matrices @param m1 and @param m2
-   * and @return whether their values are equal (boolean).
+   * Method matricesSame compares 2 matrices @param m1 and @param m2 and @return whether their
+   * values are equal (boolean).
    */
-  
+
   public static boolean matricesSame(int[][] m1, int[][] m2) {
     if (m1.length != m2.length) {
       return false;
@@ -81,12 +81,12 @@ public static boolean matricesSame(int[][] m1, int[][] m2) {
       return answer;
     }
   }
-  
+
   /**
-   * Method createRandomIntMatrix creates a random matrix of size @param rows
-   * and @param columns @return it (int[][]).
+   * Method createRandomIntMatrix creates a random matrix of size @param rows and @param columns.
+   *
+   * @return it (int[][]).
    */
-  
   public static int[][] createRandomIntMatrix(int rows, int columns) {
     int[][] matrix = new int[rows][columns];
     for (int i = 0; i < rows; i++) {
@@ -97,11 +97,11 @@ public static int[][] createRandomIntMatrix(int rows, int columns) {
     }
     return matrix;
   }
-  
+
   /**
    * Method printMatrix prints input matrix @param matrix.
    */
-  
+
   public static void printMatrix(int[][] matrix) {
     //prints out int[][]
     for (int i = 0; i < matrix.length; i++) {
@@ -111,5 +111,5 @@ public static void printMatrix(int[][] matrix) {
       LOGGER.info("");
     }
   }
-  
+
 }

master-worker-pattern/src/main/java/com/iluwatar/masterworker/Input.java

@@ -26,18 +26,19 @@
 import java.util.ArrayList;
 
 /**
- *The abstract Input class, having 1 public field which contains input data,
- *and abstract method divideData.
+ * The abstract Input class, having 1 public field which contains input data, and abstract method
+ * divideData.
+ *
  * @param <T> T will be type of data.
  */
 
 public abstract class Input<T> {
-  
+
   public final T data;
-  
+
   public Input(T data) {
     this.data = data;
   }
-  
+
   public abstract ArrayList<Input> divideData(int num);
 }

master-worker-pattern/src/main/java/com/iluwatar/masterworker/Result.java

@@ -24,13 +24,13 @@
 package com.iluwatar.masterworker;
 
 /**
- *The abstract Result class, which contains 1 public field containing result
- *data.
+ * The abstract Result class, which contains 1 public field containing result data.
+ *
  * @param <T> T will be type of data.
  */
 
 public abstract class Result<T> {
-  
+
   public final T data;
 
   public Result(T data) {