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

mute-idiom/src/main/java/com/iluwatar/mute/App.java

@@ -23,19 +23,17 @@
 
 package com.iluwatar.mute;
 
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.sql.SQLException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /**
- * Mute pattern is utilized when we need to suppress an exception due to an API flaw or in 
- * situation when all we can do to handle the exception is to log it. 
- * This pattern should not be used everywhere. It is very important to logically handle the 
- * exceptions in a system, but some situations like the ones described above require this pattern, 
- * so that we don't need to repeat 
+ * Mute pattern is utilized when we need to suppress an exception due to an API flaw or in situation
+ * when all we can do to handle the exception is to log it. This pattern should not be used
+ * everywhere. It is very important to logically handle the exceptions in a system, but some
+ * situations like the ones described above require this pattern, so that we don't need to repeat
  * <pre>
  * <code>
  *   try {
@@ -45,7 +43,6 @@ import java.sql.SQLException;
  *   }
  * </code>
  * </pre> every time we need to ignore an exception.
- * 
  */
 public class App {
 
@@ -53,7 +50,7 @@ public class App {
 
   /**
    * Program entry point.
-   * 
+   *
    * @param args command line args.
    * @throws Exception if any exception occurs
    */
@@ -65,7 +62,7 @@ public class App {
   }
 
   /*
-   * Typically used when the API declares some exception but cannot do so. Usually a 
+   * Typically used when the API declares some exception but cannot do so. Usually a
    * signature mistake.In this example out is not supposed to throw exception as it is a
    * ByteArrayOutputStream. So we utilize mute, which will throw AssertionError if unexpected
    * exception occurs.
@@ -98,7 +95,7 @@ public class App {
 
   private static Resource acquireResource() throws SQLException {
     return new Resource() {
-      
+
       @Override
       public void close() throws IOException {
         throw new IOException("Error in closing resource: " + this);

mute-idiom/src/main/java/com/iluwatar/mute/CheckedRunnable.java

@@ -25,12 +25,12 @@ package com.iluwatar.mute;
 
 /**
  * A runnable which may throw exception on execution.
- *
  */
 @FunctionalInterface
 public interface CheckedRunnable {
   /**
    * Same as {@link Runnable#run()} with a possibility of exception in execution.
+   *
    * @throws Exception if any exception occurs.
    */
   void run() throws Exception;

mute-idiom/src/main/java/com/iluwatar/mute/Mute.java

@@ -30,17 +30,18 @@ import java.io.IOException;
  * A utility class that allows you to utilize mute idiom.
  */
 public final class Mute {
-  
+
   // The constructor is never meant to be called.
-  private Mute() {}
+  private Mute() {
+  }
 
   /**
-   * Executes the <code>runnable</code> and throws the exception occurred within a {@link AssertionError}.
-   * This method should be utilized to mute the operations that are guaranteed not to throw an exception.
-   * For instance {@link ByteArrayOutputStream#write(byte[])} declares in it's signature that it can throw
-   * an {@link IOException}, but in reality it cannot. This is because the bulk write method is not overridden
-   * in {@link ByteArrayOutputStream}.
-   * 
+   * Executes the <code>runnable</code> and throws the exception occurred within a {@link
+   * AssertionError}. This method should be utilized to mute the operations that are guaranteed not
+   * to throw an exception. For instance {@link ByteArrayOutputStream#write(byte[])} declares in
+   * it's signature that it can throw an {@link IOException}, but in reality it cannot. This is
+   * because the bulk write method is not overridden in {@link ByteArrayOutputStream}.
+   *
    * @param runnable a runnable that should never throw an exception on execution.
    */
   public static void mute(CheckedRunnable runnable) {
@@ -52,11 +53,11 @@ public final class Mute {
   }
 
   /**
-   * Executes the <code>runnable</code> and logs the exception occurred on {@link System#err}.
-   * This method should be utilized to mute the operations about which most you can do is log.
-   * For instance while closing a connection to database, or cleaning up a resource, 
-   * all you can do is log the exception occurred.
-   * 
+   * Executes the <code>runnable</code> and logs the exception occurred on {@link System#err}. This
+   * method should be utilized to mute the operations about which most you can do is log. For
+   * instance while closing a connection to database, or cleaning up a resource, all you can do is
+   * log the exception occurred.
+   *
    * @param runnable a runnable that may throw an exception on execution.
    */
   public static void loggedMute(CheckedRunnable runnable) {

mute-idiom/src/main/java/com/iluwatar/mute/Resource.java

@@ -26,9 +26,8 @@ package com.iluwatar.mute;
 import java.io.Closeable;
 
 /**
- * Represents any resource that the application might acquire and that must be closed
- * after it is utilized. Example of such resources can be a database connection, open
- * files, sockets. 
+ * Represents any resource that the application might acquire and that must be closed after it is
+ * utilized. Example of such resources can be a database connection, open files, sockets.
  */
 public interface Resource extends Closeable {