#107 Double Dispatch example JavaDoc

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

@@ -8,23 +8,27 @@ 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.
- * 
+ * <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.
- * 
+ * <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).
- * 
+ * <p>
- * In this example we have hierarchy of objects (GameObject) that can collide to each other. Each
+ * 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 {
 	
+	/**
+	 * Program entry point
+	 * @param args command line args
+	 */
     public static void main( String[] args ) {
     	// initialize game objects and print their status
     	List<GameObject> objects = new ArrayList<>();

double-dispatch/src/test/java/com/iluwatar/doubledispatch/AppTest.java

@@ -4,6 +4,11 @@ import org.junit.Test;
 
 import com.iluwatar.doubledispatch.App;
 
+/**
+ * 
+ * Application test
+ *
+ */
 public class AppTest {
 	
 	@Test