Merge branch 'master' of github.com:iluwatar/java-design-patterns

dheeraj-mummareddy · dheeraj-mummareddy · commit 3894a0bb6cdf · 2018-03-04T17:33:58.000-05:00
diff --git a/abstract-factory/README.md b/abstract-factory/README.md
@@ -179,10 +179,15 @@ Use the Abstract Factory pattern when
 
 *	Dependency injection in java hides the service class dependencies that can lead to runtime errors that would have been caught at compile time.
 
+
+## Tutorial
+* [Abstract Factory Pattern Tutorial](https://www.journaldev.com/1418/abstract-factory-design-pattern-in-java) 
+
 ## Presentations
 
 * [Abstract Factory Pattern](etc/presentation.html) 
 
+
 ## Real world examples
 
 * [javax.xml.parsers.DocumentBuilderFactory](http://docs.oracle.com/javase/8/docs/api/javax/xml/parsers/DocumentBuilderFactory.html)
diff --git a/bridge/README.md b/bridge/README.md
@@ -188,6 +188,9 @@ Use the Bridge pattern when
 * you have a proliferation of classes. Such a class hierarchy indicates the need for splitting an object into two parts. Rumbaugh uses the term "nested generalizations" to refer to such class hierarchies
 * you want to share an implementation among multiple objects (perhaps using reference counting), and this fact should be hidden from the client. A simple example is Coplien's String class, in which multiple objects can share the same string representation.
 
+## Tutorial
+* [Bridge Pattern Tutorial](https://www.journaldev.com/1491/bridge-design-pattern-java)
+
 ## Credits
 
 * [Design Patterns: Elements of Reusable Object-Oriented Software](http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612)
diff --git a/decorator/README.md b/decorator/README.md
@@ -116,6 +116,9 @@ Use Decorator
 * For responsibilities that can be withdrawn
 * When extension by subclassing is impractical. Sometimes a large number of independent extensions are possible and would produce an explosion of subclasses to support every combination. Or a class definition may be hidden or otherwise unavailable for subclassing
 
+## Tutorial
+* [Decorator Pattern Tutorial](https://www.journaldev.com/1540/decorator-design-pattern-in-java-example)
+
 ## Real world examples
  * [java.io.InputStream](http://docs.oracle.com/javase/8/docs/api/java/io/InputStream.html), [java.io.OutputStream](http://docs.oracle.com/javase/8/docs/api/java/io/OutputStream.html),
  [java.io.Reader](http://docs.oracle.com/javase/8/docs/api/java/io/Reader.html) and [java.io.Writer](http://docs.oracle.com/javase/8/docs/api/java/io/Writer.html)
diff --git a/interpreter/src/test/java/com/iluwatar/interpreter/ExpressionTest.java b/interpreter/src/test/java/com/iluwatar/interpreter/ExpressionTest.java
@@ -23,6 +23,7 @@
 package com.iluwatar.interpreter;
 
 import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.TestInstance;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
@@ -43,6 +44,7 @@
  * @param <E> Type of Expression
  * @author Jeroen Meulemeester
  */
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
 public abstract class ExpressionTest<E extends Expression> {
 
   /**
@@ -88,6 +90,13 @@ static Stream<Arguments> prepareParameters(final IntBinaryOperator resultCalc) {
     this.factory = factory;
   }
 
+  /**
+   * Create a new set of test entries with the expected result
+   *
+   * @return The list of parameters used during this test
+   */
+  public abstract Stream<Arguments> expressionProvider();
+
   /**
    * Verify if the expression calculates the correct result when calling {@link E#interpret()}
    */
diff --git a/interpreter/src/test/java/com/iluwatar/interpreter/MinusExpressionTest.java b/interpreter/src/test/java/com/iluwatar/interpreter/MinusExpressionTest.java
@@ -38,7 +38,8 @@ public class MinusExpressionTest extends ExpressionTest<MinusExpression> {
    *
    * @return The list of parameters used during this test
    */
-  public static Stream<Arguments> expressionProvider() {
+  @Override
+  public Stream<Arguments> expressionProvider() {
     return prepareParameters((f, s) -> f - s);
   }
 
diff --git a/interpreter/src/test/java/com/iluwatar/interpreter/MultiplyExpressionTest.java b/interpreter/src/test/java/com/iluwatar/interpreter/MultiplyExpressionTest.java
@@ -38,7 +38,8 @@ public class MultiplyExpressionTest extends ExpressionTest<MultiplyExpression> {
    *
    * @return The list of parameters used during this test
    */
-  public static Stream<Arguments> expressionProvider() {
+  @Override
+  public Stream<Arguments> expressionProvider() {
     return prepareParameters((f, s) -> f * s);
   }
 
diff --git a/interpreter/src/test/java/com/iluwatar/interpreter/NumberExpressionTest.java b/interpreter/src/test/java/com/iluwatar/interpreter/NumberExpressionTest.java
@@ -42,7 +42,8 @@ public class NumberExpressionTest extends ExpressionTest<NumberExpression> {
    *
    * @return The list of parameters used during this test
    */
-  public static Stream<Arguments> expressionProvider() {
+  @Override
+  public Stream<Arguments> expressionProvider() {
     return prepareParameters((f, s) -> f);
   }
 
diff --git a/interpreter/src/test/java/com/iluwatar/interpreter/PlusExpressionTest.java b/interpreter/src/test/java/com/iluwatar/interpreter/PlusExpressionTest.java
@@ -38,7 +38,8 @@ public class PlusExpressionTest extends ExpressionTest<PlusExpression> {
    *
    * @return The list of parameters used during this test
    */
-  public static Stream<Arguments> expressionProvider() {
+  @Override
+  public Stream<Arguments> expressionProvider() {
     return prepareParameters((f, s) -> f + s);
   }
 
diff --git a/object-mother/src/main/java/com/iluwatar/objectmother/RoyaltyObjectMother.java b/object-mother/src/main/java/com/iluwatar/objectmother/RoyaltyObjectMother.java
@@ -28,7 +28,7 @@
 public final class RoyaltyObjectMother {
 
   /**
-   * Method to create a sober and unhappy king. The standard paramters are set.
+   * Method to create a sober and unhappy king. The standard parameters are set.
    * @return An instance of {@link com.iluwatar.objectmother.King} with the standard properties.
    */
   public static King createSoberUnhappyKing() {
diff --git a/observer/src/test/java/com/iluwatar/observer/HobbitsTest.java b/observer/src/test/java/com/iluwatar/observer/HobbitsTest.java
@@ -33,7 +33,8 @@
  */
 public class HobbitsTest extends WeatherObserverTest<Hobbits> {
 
-  static Collection<Object[]> dataProvider() {
+  @Override
+  public Collection<Object[]> dataProvider() {
     final List<Object[]> testData = new ArrayList<>();
     testData.add(new Object[]{WeatherType.SUNNY, "The happy hobbits bade in the warm sun."});
     testData.add(new Object[]{WeatherType.RAINY, "The hobbits look for cover from the rain."});
diff --git a/observer/src/test/java/com/iluwatar/observer/OrcsTest.java b/observer/src/test/java/com/iluwatar/observer/OrcsTest.java
@@ -33,7 +33,8 @@
  */
 public class OrcsTest extends WeatherObserverTest<Orcs> {
 
-  static Collection<Object[]> dataProvider() {
+  @Override
+  public Collection<Object[]> dataProvider() {
     final List<Object[]> testData = new ArrayList<>();
     testData.add(new Object[]{WeatherType.SUNNY, "The sun hurts the orcs' eyes."});
     testData.add(new Object[]{WeatherType.RAINY, "The orcs are dripping wet."});
diff --git a/observer/src/test/java/com/iluwatar/observer/WeatherObserverTest.java b/observer/src/test/java/com/iluwatar/observer/WeatherObserverTest.java
@@ -23,11 +23,14 @@
 package com.iluwatar.observer;
 
 import com.iluwatar.observer.utils.InMemoryAppender;
+
+import java.util.Collection;
 import java.util.function.Supplier;
 
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.TestInstance;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
 
@@ -39,6 +42,7 @@
  * @param <O> Type of WeatherObserver
  * @author Jeroen Meulemeester
  */
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
 public abstract class WeatherObserverTest<O extends WeatherObserver> {
 
   private InMemoryAppender appender;
@@ -67,6 +71,8 @@ public void tearDown() {
     this.factory = factory;
   }
 
+  public abstract Collection<Object[]> dataProvider();
+
   /**
    * Verify if the weather has the expected influence on the observer
    */
diff --git a/observer/src/test/java/com/iluwatar/observer/generic/GHobbitsTest.java b/observer/src/test/java/com/iluwatar/observer/generic/GHobbitsTest.java
@@ -35,7 +35,8 @@
  */
 public class GHobbitsTest extends ObserverTest<GHobbits> {
 
-  static Collection<Object[]> dataProvider() {
+  @Override
+  public Collection<Object[]> dataProvider() {
     final List<Object[]> testData = new ArrayList<>();
     testData.add(new Object[]{WeatherType.SUNNY, "The happy hobbits bade in the warm sun."});
     testData.add(new Object[]{WeatherType.RAINY, "The hobbits look for cover from the rain."});
diff --git a/observer/src/test/java/com/iluwatar/observer/generic/ObserverTest.java b/observer/src/test/java/com/iluwatar/observer/generic/ObserverTest.java
@@ -26,9 +26,11 @@
 import com.iluwatar.observer.utils.InMemoryAppender;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.TestInstance;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
 
+import java.util.Collection;
 import java.util.function.Supplier;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
@@ -39,6 +41,7 @@
  * @param <O> Type of Observer
  * @author Jeroen Meulemeester
  */
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
 public abstract class ObserverTest<O extends Observer> {
 
   private InMemoryAppender appender;
@@ -67,6 +70,8 @@ public void tearDown() {
     this.factory = factory;
   }
 
+  public abstract Collection<Object[]> dataProvider();
+
   /**
    * Verify if the weather has the expected influence on the observer
    */
diff --git a/observer/src/test/java/com/iluwatar/observer/generic/OrcsTest.java b/observer/src/test/java/com/iluwatar/observer/generic/OrcsTest.java
@@ -35,7 +35,8 @@
  */
 public class OrcsTest extends ObserverTest<GOrcs> {
 
-  static Collection<Object[]> dataProvider() {
+  @Override
+  public Collection<Object[]> dataProvider() {
     final List<Object[]> testData = new ArrayList<>();
     testData.add(new Object[]{WeatherType.SUNNY, "The sun hurts the orcs' eyes."});
     testData.add(new Object[]{WeatherType.RAINY, "The orcs are dripping wet."});
diff --git a/pom.xml b/pom.xml
@@ -147,13 +147,13 @@
         <module>event-sourcing</module>
         <module>data-transfer-object</module>
         <module>throttling</module>
-
         <module>unit-of-work</module>
         <module>partial-response</module>
         <module>eip-wire-tap</module>
         <module>eip-splitter</module>
         <module>eip-aggregator</module>
         <module>retry</module>
+		<module>trampoline</module>
     </modules>
 
     <repositories>
diff --git a/singleton/src/main/java/com/iluwatar/singleton/ThreadSafeLazyLoadedIvoryTower.java b/singleton/src/main/java/com/iluwatar/singleton/ThreadSafeLazyLoadedIvoryTower.java
@@ -1,24 +1,20 @@
 /**
- * The MIT License
- * Copyright (c) 2014-2016 Ilkka Seppälä
+ * The MIT License Copyright (c) 2014-2016 Ilkka Seppälä
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+ * associated documentation files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge, publish, distribute,
+ * sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
  * furnished to do so, subject to the following conditions:
  *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
+ * The above copyright notice and this permission notice shall be included in all copies or
+ * substantial portions of the Software.
  *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+ * NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 package com.iluwatar.singleton;
 
@@ -34,8 +30,10 @@ public final class ThreadSafeLazyLoadedIvoryTower {
   private static ThreadSafeLazyLoadedIvoryTower instance;
 
   private ThreadSafeLazyLoadedIvoryTower() {
-  // to prevent instantiating by Reflection call
-    if (instance != null) {
+    // protect against instantiation via reflection
+    if (instance == null) {
+      instance = this;
+    } else {
       throw new IllegalStateException("Already initialized.");
     }
   }
@@ -44,7 +42,6 @@ private ThreadSafeLazyLoadedIvoryTower() {
    * The instance gets created only when it is called for first time. Lazy-loading
    */
   public static synchronized ThreadSafeLazyLoadedIvoryTower getInstance() {
-
     if (instance == null) {
       instance = new ThreadSafeLazyLoadedIvoryTower();
     }
diff --git a/strategy/README.md b/strategy/README.md
@@ -28,6 +28,9 @@ Use the Strategy pattern when
 * an algorithm uses data that clients shouldn't know about. Use the Strategy pattern to avoid exposing complex, algorithm-specific data structures
 * a class defines many behaviors, and these appear as multiple conditional statements in its operations. Instead of many conditionals, move related conditional branches into their own Strategy class
 
+## Tutorial 
+* [Strategy Pattern Tutorial](https://www.journaldev.com/1754/strategy-design-pattern-in-java-example-tutorial)
+
 ## Credits
 
 * [Design Patterns: Elements of Reusable Object-Oriented Software](http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612)
diff --git a/template-method/README.md b/template-method/README.md
@@ -24,6 +24,9 @@ The Template Method pattern should be used
 * when common behavior among subclasses should be factored and localized in a common class to avoid code duplication. This is good example of "refactoring to generalize" as described by Opdyke and Johnson. You first identify the differences in the existing code and then separate the differences into new operations. Finally, you replace the differing code with a template method that calls one of these new operations
 * to control subclasses extensions. You can define a template method that calls "hook" operations at specific points, thereby permitting extensions only at those points
 
+## Tutorial
+* [Template-method Pattern Tutorial](https://www.journaldev.com/1763/template-method-design-pattern-in-java)
+
 ## Credits
 
 * [Design Patterns: Elements of Reusable Object-Oriented Software](http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612)
diff --git a/trampoline/.gitignore b/trampoline/.gitignore
@@ -0,0 +1,2 @@
+/target/
+.idea/
diff --git a/trampoline/README.md b/trampoline/README.md
@@ -0,0 +1,45 @@
+---
+layout: pattern
+title: Trampoline
+folder: trampoline
+permalink: /patterns/trampoline/
+categories: Behavior
+tags:
+ - Java
+ - Difficulty-Intermediate
+ - Performance
+ - Recursion
+---
+
+## Intent
+Trampoline pattern is used for implementing algorithms recursively in Java without blowing the stack 
+and to interleave the execution of functions without hard coding them together
+It is possible by representing a computation in one of 2 states : done | more 
+(completed with result, or a reference to the reminder of the computation, 
+something like the way a java.util.Supplier does).
+
+
+## Explanation
+Trampoline pattern allows to define recursive algorithms by iterative loop.
+
+
+## Applicability
+Use the Trampoline pattern when
+
+* For implementing tail recursive function. This pattern allows to switch on a stackless operation.
+* For interleaving the execution of two or more functions on the same thread.
+
+## Known uses(real world examples)
+* Trampoline refers to using reflection to avoid using inner classes, for example in event listeners. 
+The time overhead of a reflection call is traded for the space overhead of an inner class. 
+Trampolines in Java usually involve the creation of a GenericListener to pass events to an outer class.
+
+
+## Tutorials 
+* [Trampolining: a practical guide for awesome Java Developers](https://medium.com/@johnmcclean/trampolining-a-practical-guide-for-awesome-java-developers-4b657d9c3076)
+* [Trampoline in java ](http://mindprod.com/jgloss/trampoline.html)
+
+## Credits
+* [library 'cyclops-react' uses the pattern](https://github.com/aol/cyclops-react)
+
+
diff --git a/trampoline/pom.xml b/trampoline/pom.xml
diff --git a/trampoline/src/main/java/com/iluwatar/trampoline/Trampoline.java b/trampoline/src/main/java/com/iluwatar/trampoline/Trampoline.java
diff --git a/trampoline/src/main/java/com/iluwatar/trampoline/TrampolineApp.java b/trampoline/src/main/java/com/iluwatar/trampoline/TrampolineApp.java
diff --git a/trampoline/src/test/java/com/iluwatar/trampoline/TrampolineAppTest.java b/trampoline/src/test/java/com/iluwatar/trampoline/TrampolineAppTest.java

Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,8 @@ public class MinusExpressionTest extends ExpressionTest<MinusExpression> {`
`38`	`38`	`*`
`39`	`39`	`* @return The list of parameters used during this test`
`40`	`40`	`*/`
`41`		`- public static Stream<Arguments> expressionProvider() {`
	`41`	`+ @Override`
	`42`	`+ public Stream<Arguments> expressionProvider() {`
`42`	`43`	`return prepareParameters((f, s) -> f - s);`
`43`	`44`	`}`
`44`	`45`
Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,8 @@ public class MultiplyExpressionTest extends ExpressionTest<MultiplyExpression> {`
`38`	`38`	`*`
`39`	`39`	`* @return The list of parameters used during this test`
`40`	`40`	`*/`
`41`		`- public static Stream<Arguments> expressionProvider() {`
	`41`	`+ @Override`
	`42`	`+ public Stream<Arguments> expressionProvider() {`
`42`	`43`	`return prepareParameters((f, s) -> f * s);`
`43`	`44`	`}`
`44`	`45`
Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,8 @@ public class NumberExpressionTest extends ExpressionTest<NumberExpression> {`
`42`	`42`	`*`
`43`	`43`	`* @return The list of parameters used during this test`
`44`	`44`	`*/`
`45`		`- public static Stream<Arguments> expressionProvider() {`
	`45`	`+ @Override`
	`46`	`+ public Stream<Arguments> expressionProvider() {`
`46`	`47`	`return prepareParameters((f, s) -> f);`
`47`	`48`	`}`
`48`	`49`
Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,8 @@ public class PlusExpressionTest extends ExpressionTest<PlusExpression> {`
`38`	`38`	`*`
`39`	`39`	`* @return The list of parameters used during this test`
`40`	`40`	`*/`
`41`		`- public static Stream<Arguments> expressionProvider() {`
	`41`	`+ @Override`
	`42`	`+ public Stream<Arguments> expressionProvider() {`
`42`	`43`	`return prepareParameters((f, s) -> f + s);`
`43`	`44`	`}`
`44`	`45`