Adjust checkstyle rules. Make checkstyle fail the build when violations are found. Correct all current checkstyle violations.

double-dispatch/src/main/java/com/iluwatar/doubledispatch/App.java

@@ -5,22 +5,20 @@ import java.util.List;
 
 /**
  * 
- * When a message with a parameter is sent to an object, the resultant behaviour is defined by the
- * implementation of that method in the receiver. Sometimes the behaviour must also be determined by
- * the type of the parameter.
+ * When a message with a parameter is sent to an object, the resultant behaviour is defined by the implementation of
+ * that method in the receiver. Sometimes the behaviour must also be determined by the type of the parameter.
  * <p>
- * One way to implement this would be to create multiple instanceof-checks for the methods
- * parameter. However, this creates a maintenance issue. When new types are added we would also need
- * to change the method's implementation and add a new instanceof-check. This violates the single
- * responsibility principle - a class should have only one reason to change.
+ * One way to implement this would be to create multiple instanceof-checks for the methods parameter. However, this
+ * creates a maintenance issue. When new types are added we would also need to change the method's implementation and
+ * add a new instanceof-check. This violates the single responsibility principle - a class should have only one reason
+ * to change.
  * <p>
- * Instead of the instanceof-checks a better way is to make another virtual call on the parameter
- * object. This way new functionality can be easily added without the need to modify existing
- * implementation (open-closed principle).
+ * Instead of the instanceof-checks a better way is to make another virtual call on the parameter object. This way new
+ * functionality can be easily added without the need to modify existing implementation (open-closed principle).
  * <p>
- * In this example we have hierarchy of objects ({@link GameObject}) that can collide to each other.
- * Each object has its own coordinates which are checked against the other objects' coordinates. If
- * there is an overlap, then the objects collide utilizing the Double Dispatch pattern.
+ * In this example we have hierarchy of objects ({@link GameObject}) that can collide to each other. Each object has its
+ * own coordinates which are checked against the other objects' coordinates. If there is an overlap, then the objects
+ * collide utilizing the Double Dispatch pattern.
  *
  */
 public class App {
@@ -28,7 +26,8 @@ public class App {
   /**
    * Program entry point
    * 
-   * @param args command line args
+   * @param args
+   *          command line args
    */
   public static void main(String[] args) {
     // initialize game objects and print their status
@@ -42,8 +41,9 @@ public class App {
 
     // collision check
     objects.stream().forEach(o1 -> objects.stream().forEach(o2 -> {
-      if (o1 != o2 && o1.intersectsWith(o2))
+      if (o1 != o2 && o1.intersectsWith(o2)) {
         o1.collision(o2);
+      }
     }));
     System.out.println("");
 

double-dispatch/src/main/java/com/iluwatar/doubledispatch/Rectangle.java

@@ -12,6 +12,9 @@ public class Rectangle {
   private int right;
   private int bottom;
 
+  /**
+   * Constructor
+   */
   public Rectangle(int left, int top, int right, int bottom) {
     this.left = left;
     this.top = top;