Design Patterns and Principles

Author: turingfly

Java-8/src/designPatternsAndPrinciples/ComposingObjects.java

@@ -0,0 +1,41 @@
+package designPatternsAndPrinciples;
+
+/**
+ * 
+ * @author chengfeili Jun 4, 2017 11:12:31 PM
+ *
+ *         In object‐oriented design, we refer to object composition as the
+ *         property of constructing a class using references to other classes in
+ *         order to reuse the functionality of the other classes.
+ */
+
+class Flippers {
+	public void flap() {
+		System.out.println("The flippers flap back and forth");
+	}
+}
+
+class WebbedFeet {
+	public void kick() {
+		System.out.println("The webbed feet kick to and fro");
+	}
+}
+
+public class ComposingObjects {
+	private final Flippers flippers;
+	private final WebbedFeet webbedFeet;
+
+	public ComposingObjects() {
+		this.flippers = new Flippers();
+		this.webbedFeet = new WebbedFeet();
+	}
+
+	public void flap() {
+		this.flippers.flap();
+	}
+
+	public void kick() {
+
+		this.webbedFeet.kick();
+	}
+}

Java-8/src/designPatternsAndPrinciples/DefineFunctionalInterface.java

@@ -0,0 +1,33 @@
+package designPatternsAndPrinciples;
+
+/**
+ * 
+ * @author chengfeili Jun 4, 2017 10:10:08 PM
+ *
+ */
+@FunctionalInterface
+public interface DefineFunctionalInterface {
+	public void sprint(String s);
+}
+
+// 1. valid, extends from DefineFunctionalInterface
+interface Run1 extends DefineFunctionalInterface {
+}
+
+// 2. valid, override
+
+interface SprintFaster extends DefineFunctionalInterface {
+	public void sprint(String s);
+}
+
+// 3. valid, neither default and static is abstract
+
+interface Skip extends DefineFunctionalInterface {
+	public default int getHopCount(String s) {
+		return 10;
+	}
+
+	public static void skip(int speed) {
+
+	}
+}

Java-8/src/designPatternsAndPrinciples/DesingInterface.java

@@ -0,0 +1,36 @@
+package designPatternsAndPrinciples;
+
+/**
+ * 
+ * @author chengfeili 
+ * Jun 4, 2017 9:50:52 PM
+ *
+ */
+interface Fly {
+	public int getWingSpan() throws Exception;
+
+	public static final int MAX_SPEED = 100;
+
+	// default method is optionally overridden in the subclass
+	public default void land() {
+		System.out.println("Animal is landing");
+	}
+	
+	// it is available without an instance of the interface
+	public static double calculateSpeed(float distance, double time) {
+		return distance / time;
+	}
+}
+
+public class DesingInterface implements Fly {
+
+	@Override
+	public int getWingSpan() throws Exception {
+		// TODO Auto-generated method stub
+		return 15;
+	}
+
+	public void land() {
+		System.out.println("Eagle is diving fast");
+	}
+}

Java-8/src/designPatternsAndPrinciples/ExtendInterface.java

@@ -0,0 +1,40 @@
+package designPatternsAndPrinciples;
+
+/**
+ * 
+ * @author chengfeili 
+ * Jun 4, 2017 9:59:54 PM
+ *
+ */
+interface Walk {
+	boolean isQuadruped();
+
+	abstract double getMaxSpeed();
+}
+
+interface Run extends Walk {
+	public abstract boolean canHuntWhileRunning();
+
+	abstract double getMaxSpeed();
+}
+
+public class ExtendInterface implements Run {
+
+	@Override
+	public boolean isQuadruped() {
+		// TODO Auto-generated method stub
+		return true;
+	}
+
+	@Override
+	public boolean canHuntWhileRunning() {
+		// TODO Auto-generated method stub
+		return true;
+	}
+
+	@Override
+	public double getMaxSpeed() {
+		// TODO Auto-generated method stub
+		return 100;
+	}
+}

Java-8/src/designPatternsAndPrinciples/ImplementingFunctionalInterfacesWithLambdas.java

@@ -0,0 +1,80 @@
+package designPatternsAndPrinciples;
+
+import java.util.function.Predicate;
+
+/**
+ * 
+ * @author chengfeili 
+ * Jun 4, 2017 10:18:55 PM
+ *
+ *
+ *	---------Valid lambda syntax:------------------
+ *	() -> new Duck()
+ *	d -> {return d.quack();}
+ *	(Duck d) -> d.quack()
+ *	(Animal a, Duck d) -> d.quack()
+ *	
+ *	() - true
+ *	a -> {return a.startsWith("a");}
+ *	(String a) -> a.startsWith("a)
+ *	(int x) -> {}
+ *	(int y) -> {return;}
+ *	(a, b) -> a.startsWith("a)
+ *	
+ *
+ *	-----------Invalid lambda syntax: ---------------
+ *	Duck d -> d.quack()      	 	==> (Duck d) -> d.quack()
+ *	a,d -> d.quack()                ==> (a, d) -> d.quack()
+ *	Animal a, Duck d -> d.quack()   ==> (Animal a, Duck d) -> d.quack()
+ *
+ *	a, b - a.startsWith("a")        ==> (a, b) -> a.startsWith("a")
+ *
+ *	(when one parameter has a data type listed, though, 
+ *	all parameters must provide a data type)
+ *	(int y, z) -> {int x = 1; return y + 10;}  
+ * 	
+ *	(a, b) -> {int a = 0; return 5;}  (a is redeclared)
+ */
+class Animal {
+	private String species;
+	private boolean canHop;
+	private boolean canSwim;
+
+	public Animal(String species, boolean canHop, boolean canSwim) {
+		this.species = species;
+		this.canHop = canHop;
+		this.canSwim = canSwim;
+	}
+
+	public boolean canHop() {
+		return canHop;
+	}
+
+	public boolean canSwim() {
+		return canSwim;
+	}
+
+	public String toString() {
+		return species;
+	}
+}
+
+interface CheckTrait {
+	public boolean test(Animal a);
+}
+
+public class ImplementingFunctionalInterfacesWithLambdas {
+
+	private static void print(Animal animal, Predicate<Animal> trait) {
+		if (trait.test(animal))
+			System.out.println(animal);
+	}
+
+	public static void main(String[] args) {
+
+		// Java relies on context when  figuring out what lambda expressions mean
+		// a -> a.canHop()    ==>   (Animal a) -> {return a.canHop();}
+		print(new Animal("fish", false, true), a -> a.canHop());
+		print(new Animal("kangaroo", true, false), a -> a.canHop());
+	}
+}

Java-8/src/designPatternsAndPrinciples/ImplementingPolymorphism.java

@@ -0,0 +1,38 @@
+package designPatternsAndPrinciples;
+
+/**
+ * 
+ * @author chengfeili 
+ * Jun 4, 2017 10:45:20 PM 
+ * 
+ * Polymorphism is the ability of a single interface to support 
+ * multiple underlying forms. In Java, this allows multiple types
+ * of objects to be passed to a single method or class.
+ */
+interface LivesInOcean {
+	public void makeSound();
+}
+
+class Dolphin implements LivesInOcean {
+	public void makeSound() {
+		System.out.println("whistle");
+	}
+}
+
+class Whale implements LivesInOcean {
+	public void makeSound() {
+		System.out.println("sing");
+	}
+}
+
+public class ImplementingPolymorphism {
+	public void checkSound(LivesInOcean animal) {
+		animal.makeSound();
+	}
+
+	public static void main(String[] args) {
+		ImplementingPolymorphism o = new ImplementingPolymorphism();
+		o.checkSound(new Dolphin()); // whistle
+		o.checkSound(new Whale()); // sing
+	}
+}

Java-8/src/designPatternsAndPrinciples/OneObjectTakeManyDifferentForms.java

@@ -0,0 +1,68 @@
+package designPatternsAndPrinciples;
+
+/**
+ * 
+ * @author chengfeili Jun 4, 2017 10:52:45 PM
+ * 
+ *         If you use a variable to refer to an object, then only the methods or
+ *         variables that are part of the variable’s reference type can be
+ *         called without an explicit
+ * 
+ *         --------Object and reference-------- 
+ *         In Java, all objects are
+ *         accessed by reference, so as a developer you never have direct access
+ *         to the memory of the object itself.
+ * 
+ *         1. The type of the object determines which properties exist within
+ *         the object in memory. 
+ *         2. The type of the reference to the object
+ *         determines which methods and variables are accessible to the Java
+ *         program.
+ * 
+ * 
+ *         --------Casting Object reference--------
+ * 
+ *         1. Casting an object from a subclass to a superclass doesn’t require
+ *         an explicit cast. 
+ *         2. Casting an object from a superclass to a
+ *         subclass requires an explicit cast. 
+ *         3. The compiler will not allow
+ *         casts to unrelated types. 
+ *         4. Even when the code compiles without
+ *         issue, an exception may be thrown at runtime if the object being cast
+ *         is not actually an instance of that class.
+ */
+
+class Primate {
+	public boolean hasHair() {
+		return true;
+	}
+}
+
+interface HasTail {
+	public boolean isTailStriped();
+}
+
+public class OneObjectTakeManyDifferentForms extends Primate implements HasTail {
+	public int age = 10;
+
+	public boolean isTailStriped() {
+		return false;
+	}
+
+	public static void main(String[] args) {
+		OneObjectTakeManyDifferentForms lemur = new OneObjectTakeManyDifferentForms();
+		System.out.println(lemur.age); // 10
+
+		HasTail hasTail = lemur;
+		System.out.println(hasTail.isTailStriped()); // false
+		// System.out.println(hasTail.hasHair()); // Does not compile
+
+		Primate primate = lemur;
+		// OneObjectTakeManyDifferentForms lemur2 = primate; // Does not compile
+		// OneObjectTakeManyDifferentForms lemur2 =
+		// OneObjectTakeManyDifferentForms)primate;
+		System.out.println(primate.hasHair()); // true
+
+	}
+}