#502 Replaced usages of System.out with logger.

lazy-loading/src/main/java/com/iluwatar/lazy/loading/App.java

@@ -22,6 +22,9 @@
  */
 package com.iluwatar.lazy.loading;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /**
  * 
  * Lazy loading idiom defers object creation until needed.
@@ -33,6 +36,9 @@ package com.iluwatar.lazy.loading;
  *
  */
 public class App {
+
+  private static final Logger LOGGER = LoggerFactory.getLogger(App.class);
+
   /**
    * Program entry point
    * 
@@ -43,16 +49,16 @@ public class App {
     // Simple lazy loader - not thread safe
     HolderNaive holderNaive = new HolderNaive();
     Heavy heavy = holderNaive.getHeavy();
-    System.out.println("heavy=" + heavy);
+    LOGGER.info("heavy={}", heavy);
 
     // Thread safe lazy loader, but with heavy synchronization on each access
     HolderThreadSafe holderThreadSafe = new HolderThreadSafe();
     Heavy another = holderThreadSafe.getHeavy();
-    System.out.println("another=" + another);
+    LOGGER.info("another={}", another);
 
     // The most efficient lazy loader utilizing Java 8 features
     Java8Holder java8Holder = new Java8Holder();
     Heavy next = java8Holder.getHeavy();
-    System.out.println("next=" + next);
+    LOGGER.info("next={}", next);
   }
 }

lazy-loading/src/main/java/com/iluwatar/lazy/loading/Heavy.java

@@ -22,6 +22,9 @@
  */
 package com.iluwatar.lazy.loading;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /**
  * 
  * Heavy objects are expensive to create.
@@ -29,16 +32,18 @@ package com.iluwatar.lazy.loading;
  */
 public class Heavy {
 
+  private static final Logger LOGGER = LoggerFactory.getLogger(Heavy.class);
+
   /**
    * Constructor
    */
   public Heavy() {
-    System.out.println("Creating Heavy ...");
+    LOGGER.info("Creating Heavy ...");
     try {
       Thread.sleep(1000);
     } catch (InterruptedException e) {
-      e.printStackTrace();
+      LOGGER.error("Exception caught.", e);
     }
-    System.out.println("... Heavy created");
+    LOGGER.info("... Heavy created");
   }
 }

lazy-loading/src/main/java/com/iluwatar/lazy/loading/HolderNaive.java

@@ -22,6 +22,9 @@
  */
 package com.iluwatar.lazy.loading;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /**
  * 
  * Simple implementation of the lazy loading idiom. However, this is not thread safe.
@@ -29,13 +32,15 @@ package com.iluwatar.lazy.loading;
  */
 public class HolderNaive {
 
+  private static final Logger LOGGER = LoggerFactory.getLogger(HolderNaive.class);
+
   private Heavy heavy;
 
   /**
    * Constructor
    */
   public HolderNaive() {
-    System.out.println("HolderNaive created");
+    LOGGER.info("HolderNaive created");
   }
 
   /**

lazy-loading/src/main/java/com/iluwatar/lazy/loading/HolderThreadSafe.java

@@ -22,6 +22,9 @@
  */
 package com.iluwatar.lazy.loading;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /**
  * 
  * Same as HolderNaive but with added synchronization. This implementation is thread safe, but each
@@ -30,13 +33,15 @@ package com.iluwatar.lazy.loading;
  */
 public class HolderThreadSafe {
 
+  private static final Logger LOGGER = LoggerFactory.getLogger(HolderThreadSafe.class);
+
   private Heavy heavy;
 
   /**
    * Constructor
    */
   public HolderThreadSafe() {
-    System.out.println("HolderThreadSafe created");
+    LOGGER.info("HolderThreadSafe created");
   }
 
   /**

lazy-loading/src/main/java/com/iluwatar/lazy/loading/Java8Holder.java

@@ -22,6 +22,9 @@
  */
 package com.iluwatar.lazy.loading;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 import java.util.function.Supplier;
 
 /**
@@ -32,10 +35,12 @@ import java.util.function.Supplier;
  */
 public class Java8Holder {
 
+  private static final Logger LOGGER = LoggerFactory.getLogger(Java8Holder.class);
+
   private Supplier<Heavy> heavy = () -> createAndCacheHeavy();
 
   public Java8Holder() {
-    System.out.println("Java8Holder created");
+    LOGGER.info("Java8Holder created");
   }
 
   public Heavy getHeavy() {