Resolves checkstyle errors for trampoline twin typeobjectpattern unit-of-work value-object (#1074)

* Reduces checkstyle errors in trampoline

* Reduces checkstyle errors in twin

* Reduces checkstyle errors in typeobjectpattern

* Reduces checkstyle errors in unit-of-work

* Reduces checkstyle errors in value-object

trampoline/src/main/java/com/iluwatar/trampoline/Trampoline.java

@@ -26,12 +26,14 @@ package com.iluwatar.trampoline;
 import java.util.stream.Stream;
 
 /**
- * <p>Trampoline pattern allows to define recursive algorithms by iterative loop </p>
+ * Trampoline pattern allows to define recursive algorithms by iterative loop.
+ *
  * <p>When get is called on the returned Trampoline, internally it will iterate calling ‘jump’
- * on the returned Trampoline as long as the concrete instance returned is {@link #more(Trampoline)},
+ * on the returned Trampoline as long as the concrete instance returned is {@link
- * stopping once the returned instance is {@link #done(Object)}.</p>
+ * #more(Trampoline)}, stopping once the returned instance is {@link #done(Object)}.
+ *
  * <p>Essential we convert looping via recursion into iteration,
- * the key enabling mechanism is the fact that {@link #more(Trampoline)} is a lazy operation.</p>
+ * the key enabling mechanism is the fact that {@link #more(Trampoline)} is a lazy operation.
  *
  * @param <T> is  type for returning result.
  */
@@ -40,6 +42,8 @@ public interface Trampoline<T> {
 
 
   /**
+   * Jump to next stage.
+   *
    * @return next stage
    */
   default Trampoline<T> jump() {
@@ -52,6 +56,8 @@ public interface Trampoline<T> {
   }
 
   /**
+   * Checks if complete.
+   *
    * @return true if complete
    */
   default boolean complete() {
@@ -59,7 +65,7 @@ public interface Trampoline<T> {
   }
 
   /**
-   * Created a completed Trampoline
+   * Created a completed Trampoline.
    *
    * @param result Completed result
    * @return Completed Trampoline
@@ -70,7 +76,7 @@ public interface Trampoline<T> {
 
 
   /**
-   * Create a Trampoline that has more work to do
+   * Create a Trampoline that has more work to do.
    *
    * @param trampoline Next stage in Trampoline
    * @return Trampoline with more work

trampoline/src/main/java/com/iluwatar/trampoline/TrampolineApp.java

@@ -23,20 +23,21 @@
 
 package com.iluwatar.trampoline;
 
-
 import lombok.extern.slf4j.Slf4j;
 
 /**
- * <p>Trampoline pattern allows to define recursive algorithms by iterative loop </p>
+ * Trampoline pattern allows to define recursive algorithms by iterative loop.
- * <p>it is possible to implement algorithms recursively in Java without blowing the stack
+ *
- * and to interleave the execution of functions without hard coding them together or even using threads.</p>
+ * <p>It is possible to implement algorithms recursively in Java without blowing the stack
+ * and to interleave the execution of functions without hard coding them together or even using
+ * threads.
  */
 @Slf4j
 public class TrampolineApp {
 
   /**
    * Main program for showing pattern. It does loop with factorial function.
-   * */
+   */
   public static void main(String[] args) {
     log.info("start pattern");
     Integer result = loop(10, 1).result();

twin/src/main/java/com/iluwatar/twin/App.java

@@ -26,17 +26,17 @@ package com.iluwatar.twin;
 /**
  * Twin pattern is a design pattern which provides a standard solution to simulate multiple
  * inheritance in java.
- * <p>
+ *
- * In this example, the essence of the Twin pattern is the {@link BallItem} class and
+ * <p>In this example, the essence of the Twin pattern is the {@link BallItem} class and {@link
- * {@link BallThread} class represent the twin objects to coordinate with each other(via the twin
+ * BallThread} class represent the twin objects to coordinate with each other(via the twin
  * reference) like a single class inheriting from {@link GameItem} and {@link Thread}.
  */
 
 public class App {
 
   /**
-   * Program entry point
+   * Program entry point.
-   * 
+   *
    * @param args command line args
    */
   public static void main(String[] args) throws Exception {

twin/src/main/java/com/iluwatar/twin/BallThread.java

@@ -29,7 +29,6 @@ import org.slf4j.LoggerFactory;
 /**
  * This class is a UI thread for drawing the {@link BallItem}, and provide the method for suspend
  * and resume. It hold the reference of {@link BallItem} to delegate the draw task.
- * 
  */
 
 public class BallThread extends Thread {
@@ -47,7 +46,7 @@ public class BallThread extends Thread {
   }
 
   /**
-   * Run the thread
+   * Run the thread.
    */
   public void run() {
 

twin/src/main/java/com/iluwatar/twin/GameItem.java

@@ -34,7 +34,7 @@ public abstract class GameItem {
   private static final Logger LOGGER = LoggerFactory.getLogger(GameItem.class);
 
   /**
-   * Template method, do some common logic before draw
+   * Template method, do some common logic before draw.
    */
   public void draw() {
     LOGGER.info("draw");

typeobjectpattern/src/main/java/com/iluwatar/typeobject/App.java

@@ -29,8 +29,9 @@ import org.json.simple.parser.ParseException;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-/**<p>Type object pattern is the pattern we use when the OOP concept of creating a base class and
+/**
- * inheriting from it just doesn't work for the case in hand. This happens when we either don't know 
+ * <p>Type object pattern is the pattern we use when the OOP concept of creating a base class and
+ * inheriting from it just doesn't work for the case in hand. This happens when we either don't know
  * what types we will need upfront, or want to be able to modify or add new types conveniently w/o
  * recompiling repeatedly. The pattern provides a solution by allowing flexible creation of required
  * objects by creating one class, which has a field which represents the 'type' of the object.</p>
@@ -40,17 +41,19 @@ import org.slf4j.LoggerFactory;
  * Type. We have a json file {@link candy} which contains the details about the candies, and this is
  * parsed to get all the different candies in {@link JsonParser}. The {@link Cell} class is what the
  * game matrix is made of, which has the candies that are to be crushed, and contains information on
- * how crushing can be done, how the matrix is to be reconfigured and how points are to be gained. 
+ * how crushing can be done, how the matrix is to be reconfigured and how points are to be gained.
  * The {@link CellPool} class is a pool which reuses the candy cells that have been crushed instead
  * of making new ones repeatedly. The {@link CandyGame} class has the rules for the continuation of
- * the game and the {@link App} class has the game itself.</p> 
+ * the game and the {@link App} class has the game itself.</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) throws FileNotFoundException, IOException, ParseException {
@@ -61,7 +64,7 @@ public class App {
     var start = System.currentTimeMillis();
     var end = System.currentTimeMillis();
     var round = 0;
-    while (pointsWon < toWin && end - start < givenTime) {      
+    while (pointsWon < toWin && end - start < givenTime) {
       round++;
       var pool = new CellPool(numOfRows * numOfRows + 5);
       var cg = new CandyGame(numOfRows, pool);
@@ -72,7 +75,7 @@ public class App {
       }
       cg.printGameStatus();
       end = System.currentTimeMillis();
-      cg.round((int)(end - start), givenTime);
+      cg.round((int) (end - start), givenTime);
       pointsWon += cg.totalPoints;
       end = System.currentTimeMillis();
     }

typeobjectpattern/src/main/java/com/iluwatar/typeobject/Candy.java

@@ -24,20 +24,22 @@
 package com.iluwatar.typeobject;
 
 /**
- * The Candy class has a field type, which represents the 'type' of candy. The objects
+ * The Candy class has a field type, which represents the 'type' of candy. The objects are created
- * are created by parsing the candy.json file.
+ * by parsing the candy.json file.
  */
-
 public class Candy {
-  
+
-  enum Type { crushableCandy, rewardFruit };
+  enum Type {
-  
+    crushableCandy,
+    rewardFruit
+  }
+
   String name;
   Candy parent;
   String parentName;
   private int points;
   private Type type;
-  
+
   Candy(String name, String parentName, Type type, int points) {
     this.name = name;
     this.parent = null;
@@ -45,15 +47,15 @@ public class Candy {
     this.points = points;
     this.parentName = parentName;
   }
-  
+
   int getPoints() {
     return this.points;
   }
-  
+
   void setPoints(int a) {
     this.points = a;
   }
-  
+
   Type getType() {
     return this.type;
   }

typeobjectpattern/src/main/java/com/iluwatar/typeobject/CandyGame.java

@@ -23,24 +23,24 @@
 
 package com.iluwatar.typeobject;
 
-import java.util.ArrayList;
 import com.iluwatar.typeobject.Candy.Type;
+import java.util.ArrayList;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 /**
- * The CandyGame class contains the rules for the continuation of the game and has
+ * The CandyGame class contains the rules for the continuation of the game and has the game matrix
- * the game matrix (field 'cells') and totalPoints gained during the game.
+ * (field 'cells') and totalPoints gained during the game.
  */
 
 public class CandyGame {
 
   private static final Logger LOGGER = LoggerFactory.getLogger(CandyGame.class);
-  
+
   Cell[][] cells;
   CellPool pool;
   int totalPoints;
-  
+
   CandyGame(int num, CellPool pool) {
     this.cells = new Cell[num][num];
     this.pool = pool;
@@ -48,12 +48,12 @@ public class CandyGame {
     for (var i = 0; i < num; i++) {
       for (var j = 0; j < num; j++) {
         this.cells[i][j] = this.pool.getNewCell();
-        this.cells[i][j].xIndex = j;
+        this.cells[i][j].positionX = j;
-        this.cells[i][j].yIndex = i;
+        this.cells[i][j].positionY = i;
       }
     }
   }
-  
+
   static String numOfSpaces(int num) {
     String result = "";
     for (var i = 0; i < num; i++) {
@@ -61,7 +61,7 @@ public class CandyGame {
     }
     return result;
   }
-  
+
   void printGameStatus() {
     LOGGER.info("");
     for (var i = 0; i < cells.length; i++) {
@@ -79,32 +79,32 @@ public class CandyGame {
     }
     LOGGER.info("");
   }
-  
+
-  ArrayList<Cell> adjacentCells(int yIndex, int xIndex) {
+  ArrayList<Cell> adjacentCells(int y, int x) {
     ArrayList<Cell> adjacent = new ArrayList<Cell>();
-    if (yIndex == 0) {
+    if (y == 0) {
-      adjacent.add(this.cells[1][xIndex]);
+      adjacent.add(this.cells[1][x]);
     }
-    if (xIndex == 0) {
+    if (x == 0) {
-      adjacent.add(this.cells[yIndex][1]);
+      adjacent.add(this.cells[y][1]);
     }
-    if (yIndex == cells.length - 1) {
+    if (y == cells.length - 1) {
-      adjacent.add(this.cells[cells.length - 2][xIndex]);
+      adjacent.add(this.cells[cells.length - 2][x]);
     }
-    if (xIndex == cells.length - 1) {
+    if (x == cells.length - 1) {
-      adjacent.add(this.cells[yIndex][cells.length - 2]);
+      adjacent.add(this.cells[y][cells.length - 2]);
     }
-    if (yIndex > 0 && yIndex < cells.length - 1) {
+    if (y > 0 && y < cells.length - 1) {
-      adjacent.add(this.cells[yIndex - 1][xIndex]);
+      adjacent.add(this.cells[y - 1][x]);
-      adjacent.add(this.cells[yIndex + 1][xIndex]);
+      adjacent.add(this.cells[y + 1][x]);
     }
-    if (xIndex > 0 && xIndex < cells.length - 1) {
+    if (x > 0 && x < cells.length - 1) {
-      adjacent.add(this.cells[yIndex][xIndex - 1]);
+      adjacent.add(this.cells[y][x - 1]);
-      adjacent.add(this.cells[yIndex][xIndex + 1]);
+      adjacent.add(this.cells[y][x + 1]);
     }
     return adjacent;
   }
-   
+
   boolean continueRound() {
     for (var i = 0; i < this.cells.length; i++) {
       if (this.cells[cells.length - 1][i].candy.getType().equals(Type.rewardFruit)) {
@@ -114,7 +114,7 @@ public class CandyGame {
     for (var i = 0; i < this.cells.length; i++) {
       for (var j = 0; j < this.cells.length; j++) {
         if (!this.cells[i][j].candy.getType().equals(Type.rewardFruit)) {
-          var adj = adjacentCells(i,j);
+          var adj = adjacentCells(i, j);
           for (var a = 0; a < adj.size(); a++) {
             if (this.cells[i][j].candy.name.equals(adj.get(a).candy.name)) {
               return true;
@@ -125,13 +125,13 @@ public class CandyGame {
     }
     return false;
   }
-  
+
   void handleChange(int points) {
     LOGGER.info("+" + points + " points!");
-    this.totalPoints += points; 
+    this.totalPoints += points;
     printGameStatus();
   }
-  
+
   void round(int timeSoFar, int totalTime) {
     var start = System.currentTimeMillis();
     var end = System.currentTimeMillis();
@@ -148,9 +148,9 @@ public class CandyGame {
       for (var i = 0; i < this.cells.length; i++) {
         var j = cells.length - 1;
         var points = 0;
-        while (j > 0) { 
+        while (j > 0) {
           points = this.cells[j][i].interact(this.cells[j - 1][i], this.pool, this.cells);
-          if (points != 0) {  
+          if (points != 0) {
             handleChange(points);
           } else {
             j = j - 1;
@@ -160,7 +160,7 @@ public class CandyGame {
       for (var i = 0; i < this.cells.length; i++) {
         var j = 0;
         var points = 0;
-        while (j < cells.length - 1) {       
+        while (j < cells.length - 1) {
           points = this.cells[i][j].interact(this.cells[i][j + 1], this.pool, this.cells);
           if (points != 0) {
             handleChange(points);
@@ -172,5 +172,5 @@ public class CandyGame {
       end = System.currentTimeMillis();
     }
   }
- 
+
 }

typeobjectpattern/src/main/java/com/iluwatar/typeobject/Cell.java

@@ -26,61 +26,61 @@ package com.iluwatar.typeobject;
 import com.iluwatar.typeobject.Candy.Type;
 
 /**
- * The Cell object is what the game matrix is made of and contains the candy which is
+ * The Cell object is what the game matrix is made of and contains the candy which is to be crushed
- * to be crushed or collected as reward.
+ * or collected as reward.
  */
-
 public class Cell {
   Candy candy;
-  int xIndex;
+  int positionX;
-  int yIndex;
+  int positionY;
-  
+
-  Cell(Candy candy, int xIndex, int yIndex) {
+  Cell(Candy candy, int positionX, int positionY) {
     this.candy = candy;
-    this.xIndex = xIndex;
+    this.positionX = positionX;
-    this.yIndex = yIndex;
+    this.positionY = positionY;
   }
-  
+
   Cell() {
     this.candy = null;
-    this.xIndex = 0;
+    this.positionX = 0;
-    this.yIndex = 0;
+    this.positionY = 0;
   }
-  
+
   void crush(CellPool pool, Cell[][] cellMatrix) {
     //take out from this position and put back in pool
     pool.addNewCell(this);
     this.fillThisSpace(pool, cellMatrix);
   }
-  
+
   void fillThisSpace(CellPool pool, Cell[][] cellMatrix) {
-    for (var y = this.yIndex; y > 0; y--) {
+    for (var y = this.positionY; y > 0; y--) {
-      cellMatrix[y][this.xIndex] = cellMatrix[y - 1][this.xIndex];
+      cellMatrix[y][this.positionX] = cellMatrix[y - 1][this.positionX];
-      cellMatrix[y][this.xIndex].yIndex = y;
+      cellMatrix[y][this.positionX].positionY = y;
     }
     var newC = pool.getNewCell();
-    cellMatrix[0][this.xIndex] = newC;
+    cellMatrix[0][this.positionX] = newC;
-    cellMatrix[0][this.xIndex].xIndex = this.xIndex;
+    cellMatrix[0][this.positionX].positionX = this.positionX;
-    cellMatrix[0][this.xIndex].yIndex = 0;
+    cellMatrix[0][this.positionX].positionY = 0;
   }
-  
+
   void handleCrush(Cell c, CellPool pool, Cell[][] cellMatrix) {
-    if (this.yIndex >= c.yIndex) {      
+    if (this.positionY >= c.positionY) {
-      this.crush(pool, cellMatrix);       
+      this.crush(pool, cellMatrix);
       c.crush(pool, cellMatrix);
     } else {
       c.crush(pool, cellMatrix);
       this.crush(pool, cellMatrix);
     }
   }
-  
+
   int interact(Cell c, CellPool pool, Cell[][] cellMatrix) {
-    if (this.candy.getType().equals(Type.rewardFruit) || c.candy.getType().equals(Type.rewardFruit)) {
+    if (this.candy.getType().equals(Type.rewardFruit) || c.candy.getType()
+        .equals(Type.rewardFruit)) {
       return 0;
     } else {
       if (this.candy.name.equals(c.candy.name)) {
         var pointsWon = this.candy.getPoints() + c.candy.getPoints();
-        handleCrush(c,pool,cellMatrix);
+        handleCrush(c, pool, cellMatrix);
         return pointsWon;
       } else {
         return 0;

typeobjectpattern/src/main/java/com/iluwatar/typeobject/CellPool.java

@@ -23,18 +23,17 @@
 
 package com.iluwatar.typeobject;
 
+import com.iluwatar.typeobject.Candy.Type;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.util.ArrayList;
-import java.util.Enumeration;
 import java.util.Random;
 import org.json.simple.parser.ParseException;
-import com.iluwatar.typeobject.Candy.Type;
 
 /**
- * The CellPool class allows the reuse of crushed cells instead of creation of new
+ * The CellPool class allows the reuse of crushed cells instead of creation of new cells each time.
- * cells each time. The reused cell is given a new candy to hold using the randomCode
+ * The reused cell is given a new candy to hold using the randomCode field which holds all the
- * field which holds all the candies available.
+ * candies available.
  */
 
 public class CellPool {
@@ -42,9 +41,9 @@ public class CellPool {
   ArrayList<Cell> pool;
   int pointer;
   Candy[] randomCode;
-  
+
   CellPool(int num) {
-    this.pool = new ArrayList<Cell>(num);    
+    this.pool = new ArrayList<Cell>(num);
     try {
       this.randomCode = assignRandomCandytypes();
     } catch (Exception e) {
@@ -64,25 +63,25 @@ public class CellPool {
     }
     this.pointer = num - 1;
   }
-  
+
   Cell getNewCell() {
     var newCell = this.pool.remove(pointer);
     pointer--;
     return newCell;
   }
-  
+
   void addNewCell(Cell c) {
     c.candy = randomCode[RANDOM.nextInt(randomCode.length)]; //changing candytype to new
     this.pool.add(c);
     pointer++;
   }
-  
+
   Candy[] assignRandomCandytypes() throws FileNotFoundException, IOException, ParseException {
     var jp = new JsonParser();
     jp.parse();
     var randomCode = new Candy[jp.candies.size() - 2]; //exclude generic types 'fruit' and 'candy'
     var i = 0;
-    for (var e = jp.candies.keys(); e.hasMoreElements();) {
+    for (var e = jp.candies.keys(); e.hasMoreElements(); ) {
       var s = e.nextElement();
       if (!s.equals("fruit") && !s.equals("candy")) {
         //not generic

typeobjectpattern/src/main/java/com/iluwatar/typeobject/JsonParser.java

@@ -23,6 +23,7 @@
 
 package com.iluwatar.typeobject;
 
+import com.iluwatar.typeobject.Candy.Type;
 import java.io.File;
 import java.io.FileNotFoundException;
 import java.io.FileReader;
@@ -33,16 +34,14 @@ import org.json.simple.JSONArray;
 import org.json.simple.JSONObject;
 import org.json.simple.parser.JSONParser;
 import org.json.simple.parser.ParseException;
-import com.iluwatar.typeobject.Candy.Type;
 
 /**
- * The JsonParser class helps parse the json file candy.json to get all the
+ * The JsonParser class helps parse the json file candy.json to get all the different candies.
- * different candies.
  */
 
 public class JsonParser {
   Hashtable<String, Candy> candies;
-  
+
   JsonParser() {
     this.candies = new Hashtable<String, Candy>();
   }
@@ -69,9 +68,9 @@ public class JsonParser {
     }
     setParentAndPoints();
   }
-  
+
   void setParentAndPoints() {
-    for (Enumeration<String> e = this.candies.keys(); e.hasMoreElements();) {
+    for (Enumeration<String> e = this.candies.keys(); e.hasMoreElements(); ) {
       var c = this.candies.get(e.nextElement());
       if (c.parentName == null) {
         c.parent = null;

unit-of-work/src/main/java/com/iluwatar/unitofwork/App.java

@@ -31,6 +31,7 @@ import java.util.List;
  */
 public class App {
   /**
+   * Program entry point.
    *
    * @param args no argument sent
    */

unit-of-work/src/main/java/com/iluwatar/unitofwork/IUnitOfWork.java

@@ -24,6 +24,8 @@
 package com.iluwatar.unitofwork;
 
 /**
+ * UnitOfWork interface.
+ *
  * @param <T> Any generic entity
  */
 public interface IUnitOfWork<T> {
@@ -46,7 +48,7 @@ public interface IUnitOfWork<T> {
    */
   void registerDeleted(T entity);
 
-  /***
+  /**
    * All UnitOfWork operations batched together executed in commit only.
    */
   void commit();

unit-of-work/src/main/java/com/iluwatar/unitofwork/Student.java

@@ -32,6 +32,8 @@ public class Student {
   private final String address;
 
   /**
+   * Constructor.
+   *
    * @param id      student unique id
    * @param name    name of student
    * @param address address of student

unit-of-work/src/main/java/com/iluwatar/unitofwork/StudentRepository.java

@@ -23,16 +23,14 @@
 
 package com.iluwatar.unitofwork;
 
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /**
- * {@link StudentRepository} Student database repository.
+ * {@link StudentRepository} Student database repository. supports unit of work for student data.
- * supports unit of work for student data.
  */
 public class StudentRepository implements IUnitOfWork<Student> {
   private static final Logger LOGGER = LoggerFactory.getLogger(StudentRepository.class);
@@ -41,6 +39,8 @@ public class StudentRepository implements IUnitOfWork<Student> {
   private StudentDatabase studentDatabase;
 
   /**
+   * Constructor.
+   *
    * @param context         set of operations to be perform during commit.
    * @param studentDatabase Database for student records.
    */

value-object/src/main/java/com/iluwatar/value/object/App.java

@@ -30,21 +30,20 @@ import org.slf4j.LoggerFactory;
  * A Value Object are objects which follow value semantics rather than reference semantics. This
  * means value objects' equality are not based on identity. Two value objects are equal when they
  * have the same value, not necessarily being the same object..
- * 
+ *
- * Value Objects must override equals(), hashCode() to check the equality with values. 
+ * <p>Value Objects must override equals(), hashCode() to check the equality with values. Value
- * Value Objects should be immutable so declare members final.
+ * Objects should be immutable so declare members final. Obtain instances by static factory methods.
- * Obtain instances by static factory methods.
+ * The elements of the state must be other values, including primitive types. Provide methods,
- * The elements of the state must be other values, including primitive types. 
+ * typically simple getters, to get the elements of the state. A Value Object must check equality
- * Provide methods, typically simple getters, to get the elements of the state.
+ * with equals() not ==
- * A Value Object must check equality with equals() not == 
+ *
- * 
+ * <p>For more specific and strict rules to implement value objects check the rules from Stephen
- * For more specific and strict rules to implement value objects check the rules from Stephen
+ * Colebourne's term VALJO : http://blog.joda.org/2014/03/valjos-value-java-objects.html
- * Colebourne's term VALJO : http://blog.joda.org/2014/03/valjos-value-java-objects.html 
  */
 public class App {
 
   private static final Logger LOGGER = LoggerFactory.getLogger(App.class);
-  
+
   /**
    * This practice creates three HeroStats(Value object) and checks equality between those.
    */

value-object/src/main/java/com/iluwatar/value/object/HeroStat.java

@@ -24,11 +24,11 @@
 package com.iluwatar.value.object;
 
 /**
- * HeroStat is a value object
+ * HeroStat is a value object.
- * 
+ *
  * @see <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/doc-files/ValueBased.html">
- * http://docs.oracle.com/javase/8/docs/api/java/lang/doc-files/ValueBased.html
+ *     http://docs.oracle.com/javase/8/docs/api/java/lang/doc-files/ValueBased.html
- * </a>
+ *     </a>
  */
 public class HeroStat {