Design Patterns and Principles

Author: turingfly

Java-8/src/designPatternsAndPrinciples/BuilderPattern.java

@@ -0,0 +1,46 @@
+package designPatternsAndPrinciples;
+
+import java.util.List;
+import java.util.Arrays;
+
+/**
+ * 
+ * @author chengfeili 
+ * Jun 5, 2017 10:06:52 PM
+ * 
+ *         The builder pattern is a creational pattern in which parameters are
+ *         passed to a builder object, often through method chaining, and an
+ *         object is generated with a final build call.It is often used with
+ *         immutable objects, since immutable objects do not have setter methods
+ *         and must be created with all of their parameters set, although it can
+ *         be used with mutable objects as well.
+ */
+public class BuilderPattern {
+	private String species;
+	private int age;
+	private List<String> favoriteFoods;
+
+	public BuilderPattern setAge(int age) {
+		this.age = age;
+		return this;
+	}
+
+	public BuilderPattern setSpecies(String species) {
+		this.species = species;
+		return this;
+	}
+
+	public BuilderPattern setFavoriteFoods(List<String> favoriteFoods) {
+		this.favoriteFoods = favoriteFoods;
+		return this;
+	}
+
+	public Animal build() {
+		return new Animal(species, age, favoriteFoods);
+	}
+}
+
+class BuilderPatternTest {
+	Animal flamingo = new BuilderPattern().setFavoriteFoods(Arrays.asList("algae", "insects")).setSpecies("flamingo")
+			.build();
+}

Java-8/src/designPatternsAndPrinciples/FactoryPattern.java

@@ -0,0 +1,83 @@
+package designPatternsAndPrinciples;
+
+/**
+ * 
+ * @author chengfeili 
+ * Jun 5, 2017 10:21:53 PM
+ *
+ *         The factory pattern, sometimes referred to as the factory method
+ *         pattern, is a creational pattern based on the idea of using a factory
+ *         class to produce instances of objects based on a set of input
+ *         parameters. It is similar to the builder pattern, although it is
+ *         focused on supporting class polymorphism.
+ */
+
+abstract class Food {
+	private int quantity;
+
+	public Food(int quantity) {
+		this.quantity = quantity;
+	}
+
+	public int getQuantity() {
+		return quantity;
+	}
+
+	public abstract void consumed();
+}
+
+class Hay extends Food {
+	public Hay(int quantity) {
+		super(quantity);
+	}
+
+	public void consumed() {
+		System.out.println("Hay eaten: " + getQuantity());
+	}
+}
+
+class Pellets extends Food {
+	public Pellets(int quantity) {
+		super(quantity);
+	}
+
+	public void consumed() {
+		System.out.println("Pellets eaten: " + getQuantity());
+	}
+}
+
+class Fish extends Food {
+	public Fish(int quantity) {
+		super(quantity);
+	}
+
+	public void consumed() {
+		System.out.println("Fish eaten: " + getQuantity());
+	}
+}
+
+public class FactoryPattern {
+	public static Food getFood(String animalName) {
+		switch (animalName) {
+		case "zebra":
+			return new Hay(100);
+		case "rabbit":
+			return new Pellets(5);
+		case "goat":
+			return new Pellets(30);
+		case "polar bear":
+			return new Fish(10);
+		}
+
+		// Good practice to throw an exception if no matching subclass could be
+		// found
+		throw new UnsupportedOperationException("Unsupported animal: " + animalName);
+	}
+}
+
+class ZooKeeper {
+	public static void main(String[] args) {
+		final Food food = FactoryPattern.getFood("polar bear");
+		food.consumed();
+	}
+}

Java-8/src/designPatternsAndPrinciples/ImmutableObject.java

@@ -0,0 +1,71 @@
+package designPatternsAndPrinciples;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * 
+ * @author chengfeili 
+ * Jun 5, 2017 9:47:23 PM
+ * 
+ *         The immutable object pattern is a creational pattern based on the
+ *         idea of creating objects whose state does not change after they are
+ *         created and can be easily shared across multiple classes.
+ * 
+ *         1. Use a constructor to set all properties of the object. 
+ *         2. Mark all of the instance variables private and final. 
+ *         3. Don’t define any setter methods. 
+ *         4. Don’t allow referenced mutable objects to be modified or accessed directly. 
+ *         5. Prevent methods from being overridden.
+ *         
+ */
+public class ImmutableObject {
+	private final String species;
+	private final int age;
+	private final List<String> favoriteFoods;
+
+	public ImmutableObject(String species, int age, List<String> favoriteFoods) {
+		this.species = species;
+		this.age = age;
+		if (favoriteFoods == null) {
+			throw new RuntimeException("favoriteFoods is required");
+		}
+		// User can modify the items in the List.
+		// this.favoriteFoods = favoriteFoods;
+		this.favoriteFoods = new ArrayList<String>(favoriteFoods);
+	}
+
+	public String getSpecies() {
+		return species;
+	}
+
+	public int getAge() {
+		return age;
+	}
+
+	public int getFavoriteFoodsCount() {
+		return favoriteFoods.size();
+	}
+
+	public String getFavoriteFood(int index) {
+		return favoriteFoods.get(index);
+	}
+}
+
+/*
+ * How do we modify immutable objects if they are inherently unmodifiable? The
+ * answer is, we can’t! Alternatively, we can create new immutable objects that
+ * contain all of the same information as the original object plus whatever we
+ * wanted to change.
+ */
+class ModifyImmutableObject {
+	ImmutableObject lion = new ImmutableObject("lion", 5, Arrays.asList("meat", "more meat"));
+	// Create a new Animal instance using data from the first instance
+	List<String> favoriteFoods = new ArrayList<String>();
+	{
+		for (int i = 0; i < lion.getFavoriteFoodsCount(); i++) {
+			favoriteFoods.add(lion.getFavoriteFood(i));
+		}
+	}
+}

Java-8/src/designPatternsAndPrinciples/ImplementingFunctionalInterfacesWithLambdas.java

@@ -1,5 +1,6 @@
 package designPatternsAndPrinciples;
 
+import java.util.List;
 import java.util.function.Predicate;
 
 /**
@@ -46,6 +47,10 @@ public Animal(String species, boolean canHop, boolean canSwim) {
 		this.canSwim = canSwim;
 	}
 
+	public Animal(String species2, int age, List<String> favoriteFoods) {
+		// TODO Auto-generated constructor stub
+	}
+
 	public boolean canHop() {
 		return canHop;
 	}

Java-8/src/designPatternsAndPrinciples/SingletonPattern1.java

@@ -0,0 +1,62 @@
+package designPatternsAndPrinciples;
+
+/**
+ * 
+ * @author chengfeili 
+ * Jun 5, 2017 9:14:26 PM
+ * 
+ *         The single pattern is a creational pattern focused on creating only
+ *         one instance of an object in memory within an application, sharable
+ *         by all classes and threads with the application. The globally
+ *         available object created by the singleton pattern is referred to as a
+ *         singleton.
+ * 
+ *         Singletons are used in situations where we need access to a single
+ *         set of data throughout an application. For example, application
+ *         configuration data and reusable data caches are commonly implemented
+ *         using singletons. Singletons may also be used to coordinate access to
+ *         shared resources, such as coordinating write access to a file
+ */
+
+// Method 1: Instantiate the singleton object directly in the definition of the instance reference.
+public class SingletonPattern1 {
+	private int quantity = 0;
+
+	private SingletonPattern1() {
+	}
+
+	private static final SingletonPattern1 instance = new SingletonPattern1();
+
+	public static SingletonPattern1 getInstance() {
+		return instance;
+	}
+
+	public synchronized void addHay(int amount) {
+		quantity += amount;
+	}
+
+	public synchronized boolean removeHay(int amount) {
+		if (quantity < amount)
+			return false;
+		quantity -= amount;
+		return true;
+	}
+
+	public synchronized int getHayQuantity() {
+		return quantity;
+	}
+}
+
+class LlamaTrainer {
+	public boolean feedLlamas(int numberOfLlamas) {
+		int amountNeeded = 5 * numberOfLlamas;
+		SingletonPattern1 hayStorage = SingletonPattern1.getInstance();
+		if (hayStorage.getHayQuantity() < amountNeeded) {
+			hayStorage.addHay(amountNeeded + 10);
+		}
+		boolean fed = hayStorage.removeHay(amountNeeded);
+		if (fed)
+			System.out.println("Llamas have been fed");
+		return fed;
+	}
+}

Java-8/src/designPatternsAndPrinciples/SingletonPattern2.java

@@ -0,0 +1,25 @@
+package designPatternsAndPrinciples;
+
+/**
+ * 
+ * @author chengfeili 
+ * Jun 5, 2017 9:21:24 PM
+ *
+ */
+
+// Method 2: Instantiation using a static block
+public class SingletonPattern2 {
+	private static final SingletonPattern2 instance;
+	static {
+		instance = new SingletonPattern2();
+		// Perform additional steps
+	}
+
+	private SingletonPattern2() {
+	}
+
+	public static SingletonPattern2 getInstance() {
+		return instance;
+	}
+	// Data access methods
+}

Java-8/src/designPatternsAndPrinciples/SingletonPattern3.java

@@ -0,0 +1,65 @@
+package designPatternsAndPrinciples;
+
+/**
+ * 
+ * @author chengfeili 
+ * Jun 5, 2017 9:26:12 PM
+ * 
+ *         Creating a reusable object the first time it is requested is a
+ *         software design pattern known as lazy instantiation.
+ */
+// Method 3: Lazy Instantiation. Delay creation of the singleton until the first
+// time the getInstance() method is called:
+
+public class SingletonPattern3 {
+	private static SingletonPattern3 instance;
+
+	private SingletonPattern3() {
+	}
+
+	// 1. NOT THREAD-SAFE
+	public static SingletonPattern3 getInstance() {
+		if (instance == null) {
+			instance = new SingletonPattern3();
+		}
+		return instance;
+	}
+
+	/* 2. THREAD-SAFE
+	 * 
+	 * has the problem that every single call to this method will require
+	 * synchronization. In practice, this can be costly and can impact
+	 * performance. Synchronization is only needed the first time that the
+	 * object is created.
+	 */
+	public static synchronized SingletonPattern3 getInstance2() {
+		if (instance == null) {
+			instance = new SingletonPattern3();
+		}
+		return instance;
+	}
+
+	/* 3. Double-Checked Locking
+	 * 
+	 * The solution is to use double‐checked locking, a design pattern in which
+	 * we first test if synchronization is needed before actually acquiring any
+	 * locks.
+	 * 
+	 * Volatile prevents a subtle case where the compiler tries to optimize the
+	 * code such that that the object is accessed before it is finished being
+	 * constructed.
+	 */
+	private static volatile SingletonPattern3 instance3;
+
+	public static SingletonPattern3 getInstance3() {
+		if (instance3 == null) {
+			synchronized (SingletonPattern3.class) {
+				if (instance3 == null) {
+					instance3 = new SingletonPattern3();
+				}
+			}
+		}
+		return instance;
+	}
+	// Data access methods
+}