Java Design patterns

Java Design Patterns/javadevjournal/design/creational/abstractfactory/AbstractFactory.java

@@ -0,0 +1,8 @@
+package javadevjournal.design.creational.abstractfactory;
+
+/**
+ * @author Kunwar
+ */
+public abstract class AbstractFactory {
+   abstract Shape getShape(String shapeType) ;
+}

Java Design Patterns/javadevjournal/design/creational/abstractfactory/AbstractFactoryDemo.java

@@ -0,0 +1,29 @@
+package javadevjournal.design.creational.abstractfactory;
+
+/**
+ * @author Kunwar
+ */
+public class AbstractFactoryDemo {
+   public static void main(String[] args) {
+      /* get shape factory */
+      AbstractFactory shapeFactory = FactoryOfFactory.getFactory(false);
+      /* get an object of Shape Rectangle */
+      Shape shape1 = shapeFactory.getShape("RECTANGLE");
+      /* call draw method of Shape Rectangle */
+      shape1.drawShape();
+      /* get an object of Shape Square */
+      Shape shape2 = shapeFactory.getShape("SQUARE");
+      /* call draw method of Shape Square */
+      shape2.drawShape();
+      /* get rounded shape factory */
+      AbstractFactory roundShapeFactory = FactoryOfFactory.getFactory(true);
+      /* get an object of Shape Rectangle */
+      Shape shape3 = roundShapeFactory.getShape("RECTANGLE");
+      /* call draw method of Shape Rectangle */
+      shape3.drawShape();
+      /* get an object of Shape Square */
+      Shape shape4 = roundShapeFactory.getShape("SQUARE");
+      /* call draw method of Shape Square */
+      shape4.drawShape();
+   }
+}

Java Design Patterns/javadevjournal/design/creational/abstractfactory/FactoryOfFactory.java

@@ -0,0 +1,14 @@
+package javadevjournal.design.creational.abstractfactory;
+
+/**
+ * @author Kunwar
+ */
+public class FactoryOfFactory {
+   public static AbstractFactory getFactory(boolean rounded){   
+      if(rounded){
+         return new RoundedShapeFactory();         
+      }else{
+         return new ShapeFactory();
+      }
+   }
+}

Java Design Patterns/javadevjournal/design/creational/abstractfactory/Rectangle.java

@@ -0,0 +1,11 @@
+package javadevjournal.design.creational.abstractfactory;
+
+/**
+ * @author Kunwar
+ */
+public class Rectangle implements Shape {
+   @Override
+   public void drawShape() {
+      System.out.println("Inside Rectangle::draw() method.");
+   }
+}

Java Design Patterns/javadevjournal/design/creational/abstractfactory/RoundedRectangle.java

@@ -0,0 +1,11 @@
+package javadevjournal.design.creational.abstractfactory;
+
+/**
+ * @author Kunwar
+ */
+public class RoundedRectangle implements Shape {
+   @Override
+   public void drawShape() {
+      System.out.println("Inside RoundedRectangle::draw() method.");
+   }
+}

Java Design Patterns/javadevjournal/design/creational/abstractfactory/RoundedShapeFactory.java

@@ -0,0 +1,16 @@
+package javadevjournal.design.creational.abstractfactory;
+
+/**
+ * @author Kunwar
+ */
+public class RoundedShapeFactory extends AbstractFactory {
+   @Override
+   public Shape getShape(String shapeType){    
+      if(shapeType.equalsIgnoreCase("RECTANGLE")){
+         return new RoundedRectangle();         
+      }else if(shapeType.equalsIgnoreCase("SQUARE")){
+         return new RoundedSquare();
+      }	 
+      return null;
+   }
+}

Java Design Patterns/javadevjournal/design/creational/abstractfactory/RoundedSquare.java

@@ -0,0 +1,11 @@
+package javadevjournal.design.creational.abstractfactory;
+
+/**
+ * @author Kunwar
+ */
+public class RoundedSquare implements Shape {
+   @Override
+   public void drawShape() {
+      System.out.println("Inside RoundedSquare::draw() method.");
+   }
+}

Java Design Patterns/javadevjournal/design/creational/abstractfactory/Shape.java

@@ -0,0 +1,8 @@
+package javadevjournal.design.creational.abstractfactory;
+
+/**
+ * @author Kunwar
+ */
+public interface Shape {
+   void drawShape();
+}

Java Design Patterns/javadevjournal/design/creational/abstractfactory/ShapeFactory.java

@@ -0,0 +1,16 @@
+package javadevjournal.design.creational.abstractfactory;
+
+/**
+ * @author Kunwar
+ */
+public class ShapeFactory extends AbstractFactory {
+   @Override
+   public Shape getShape(String shapeType){    
+      if(shapeType.equalsIgnoreCase("RECTANGLE")){
+         return new Rectangle();         
+      }else if(shapeType.equalsIgnoreCase("SQUARE")){
+         return new Square();
+      }	 
+      return null;
+   }
+}

Java Design Patterns/javadevjournal/design/creational/abstractfactory/Square.java

@@ -0,0 +1,11 @@
+package javadevjournal.design.creational.abstractfactory;
+
+/**
+ * @author Kunwar
+ */
+public class Square implements Shape {
+   @Override
+   public void drawShape() {
+      System.out.println("Inside Square::draw() method.");
+   }
+}

Java Design Patterns/javadevjournal/design/creational/abstractfactory/example2/AbstractFactory.java

@@ -0,0 +1,8 @@
+package javadevjournal.design.creational.abstractfactory.example2;
+
+/**
+ * Abstract Factory - Factory of Factories
+ */
+public abstract class AbstractFactory{
+   abstract IMobile getMobile(String mobileModel) ;
+}

Java Design Patterns/javadevjournal/design/creational/abstractfactory/example2/AbstractFactoryPatternDemo.java

@@ -0,0 +1,19 @@
+package javadevjournal.design.creational.abstractfactory.example2;
+
+/**
+ * Client Class
+ */
+public  class AbstractFactoryPatternDemo{
+       public static void main(String[] args){
+          AbstractFactory abstractFactory1 = MpbileFactoryProducer.getFactory(false);
+          IMobile onePlus = abstractFactory1.getMobile("Oneplus");
+          onePlus.brandName();
+          IMobile sony =  abstractFactory1.getMobile("Sony");
+          sony.brandName();
+           IMobile lava =  abstractFactory1.getMobile("Lava");
+           lava.brandName();
+          AbstractFactory abstractFactory2 = MpbileFactoryProducer.getFactory(true);
+          IMobile iphone = abstractFactory2.getMobile("iphone");
+          iphone.brandName();
+       }
+}

Java Design Patterns/javadevjournal/design/creational/abstractfactory/example2/AndroidMobileFactory.java

@@ -0,0 +1,18 @@
+package javadevjournal.design.creational.abstractfactory.example2;
+
+/**
+ * Android Mobile Factory
+ */
+public class AndroidMobileFactory extends AbstractFactory {
+       @Override
+       public IMobile getMobile(String mobileModel){
+          if(mobileModel.equalsIgnoreCase("Oneplus")){
+             return new OnePlus();         
+          }else if(mobileModel.equalsIgnoreCase("Sony")){
+             return new Sony();
+          }else if(mobileModel.equalsIgnoreCase("Lava")){
+              return new Lava();
+          }
+          return null;
+       }
+}

Java Design Patterns/javadevjournal/design/creational/abstractfactory/example2/AppleMobileFactory.java

@@ -0,0 +1,14 @@
+package javadevjournal.design.creational.abstractfactory.example2;
+
+/**
+ * Apple Mobile Factory
+ */
+public class AppleMobileFactory extends AbstractFactory{
+       @Override
+       public IMobile getMobile(String mobileModel){
+          if(mobileModel.equalsIgnoreCase("iphone")){
+             return new Iphone();         
+          } 
+          return null;
+       }
+}

Java Design Patterns/javadevjournal/design/creational/abstractfactory/example2/IMobile.java

@@ -0,0 +1,8 @@
+package javadevjournal.design.creational.abstractfactory.example2;
+
+/**
+ * Mobile
+ */
+public interface IMobile {
+    void brandName();
+}

Java Design Patterns/javadevjournal/design/creational/abstractfactory/example2/Iphone.java

@@ -0,0 +1,11 @@
+package javadevjournal.design.creational.abstractfactory.example2;
+
+/**
+ * Iphone Mobile
+ */
+public class Iphone implements IMobile {
+    @Override
+    public void brandName() {
+        System.out.println("The brand name is Iphone");
+    }
+}

Java Design Patterns/javadevjournal/design/creational/abstractfactory/example2/Lava.java

@@ -0,0 +1,11 @@
+package javadevjournal.design.creational.abstractfactory.example2;
+
+/**
+ * Nokia Mobile Concrete Class
+ */
+public class Lava implements IMobile {
+    @Override
+    public void brandName() {
+        System.out.println("The brand name is Lava");
+    }
+}

Java Design Patterns/javadevjournal/design/creational/abstractfactory/example2/MpbileFactoryProducer.java

@@ -0,0 +1,15 @@
+package javadevjournal.design.creational.abstractfactory.example2;
+
+/**
+ * Factory Producer
+ */
+public class MpbileFactoryProducer {
+       public static AbstractFactory getFactory(boolean isApple){
+          if(isApple){
+             return new AppleMobileFactory();         
+          }else{
+             return new AndroidMobileFactory();
+          }
+       }
+}
+  

Java Design Patterns/javadevjournal/design/creational/abstractfactory/example2/OnePlus.java

@@ -0,0 +1,11 @@
+package javadevjournal.design.creational.abstractfactory.example2;
+
+/**
+ * OnePlus Mobile
+ */
+public class OnePlus implements IMobile {
+    @Override
+    public void brandName() {
+        System.out.println("The brand name is OnePlus");
+    }
+}

Java Design Patterns/javadevjournal/design/creational/abstractfactory/example2/Sony.java

@@ -0,0 +1,11 @@
+package javadevjournal.design.creational.abstractfactory.example2;
+
+/**
+ * Sony Mobile
+ */
+public class Sony implements IMobile {
+    @Override
+    public void brandName() {
+        System.out.println("The brand name is Sony");
+    }
+}

Java Design Patterns/javadevjournal/design/creational/builder/BuilderPatternDemo.java

@@ -0,0 +1,26 @@
+package javadevjournal.design.creational.builder;
+
+/**
+ * @author Kunwar
+ * Builder Pattern Client Class
+ * Create Computer object with mandatory and optional properties
+ */
+public class BuilderPatternDemo {
+	public static void main(String[] args) {
+
+		Computer model1 = new Computer.ComputerBuilder(
+				"1 TB", "16 GB","15.6").setBluetoothEnabled(true)
+				.setGraphicsCardEnabled(true).setTouchScreenEnabled(true).setWebCamEnabled(true).build();
+		System.out.println("model1: " + model1.toString());
+
+		Computer model2 = new Computer.ComputerBuilder(
+				"256 GB", "8 GB","14.6").setBluetoothEnabled(true)
+				.setGraphicsCardEnabled(true).build();
+		System.out.println("model2: "+model2.toString());
+
+
+		Computer model3 = new Computer.ComputerBuilder(
+				"128 GB", "4 GB","13.6").build();
+		System.out.println("model3: "+model3.toString());
+	}
+}

Java Design Patterns/javadevjournal/design/creational/builder/Computer.java

@@ -0,0 +1,116 @@
+package javadevjournal.design.creational.builder;
+
+/**
+ * @author Kunwar
+ * Product Class
+ * Builder Pattern Class
+ */
+public class Computer {
+	//required parameters
+	private String HDD;
+	private String RAM;
+	private String screenSize;
+
+	//optional parameters
+	private boolean isGraphicsCardEnabled;
+	private boolean isBluetoothEnabled;
+	private boolean isWebCamEnabled;
+	private boolean isTouchScreenEnabled;
+
+	public String getHDD() {
+		return HDD;
+	}
+
+	public String getRAM() {
+		return RAM;
+	}
+
+	public String getScreenSize() {
+		return screenSize;
+	}
+
+	public boolean isGraphicsCardEnabled() {
+		return isGraphicsCardEnabled;
+	}
+
+	public boolean isBluetoothEnabled() {
+		return isBluetoothEnabled;
+	}
+
+	public boolean isWebCamEnabled() {
+		return isWebCamEnabled;
+	}
+
+	public boolean isTouchScreenEnabled() {
+		return isTouchScreenEnabled;
+	}
+
+	private Computer(ComputerBuilder builder) {
+		this.HDD=builder.HDD;
+		this.RAM=builder.RAM;
+		this.screenSize=builder.screenSize;
+		this.isGraphicsCardEnabled=builder.isGraphicsCardEnabled;
+		this.isBluetoothEnabled=builder.isBluetoothEnabled;
+		this.isTouchScreenEnabled=builder.isTouchScreenEnabled;
+		this.isWebCamEnabled=builder.isWebCamEnabled;
+		this.isWebCamEnabled=builder.isWebCamEnabled;
+	}
+	
+	//Builder Class
+	public static class ComputerBuilder{
+
+		// required parameters
+		private String HDD;
+		private String RAM;
+		private String screenSize;
+
+		// optional parameters
+		private boolean isGraphicsCardEnabled;
+		private boolean isBluetoothEnabled;
+		private boolean isWebCamEnabled;
+		private boolean isTouchScreenEnabled;
+
+		public ComputerBuilder(String hdd, String ram, String screenSize){
+			this.HDD=hdd;
+			this.RAM=ram;
+			this.screenSize=screenSize;
+		}
+
+		public ComputerBuilder setGraphicsCardEnabled(boolean isGraphicsCardEnabled) {
+			this.isGraphicsCardEnabled = isGraphicsCardEnabled;
+			return this;
+		}
+
+		public ComputerBuilder setBluetoothEnabled(boolean isBluetoothEnabled) {
+			this.isBluetoothEnabled = isBluetoothEnabled;
+			return this;
+		}
+
+		public ComputerBuilder setWebCamEnabled(boolean webCamEnabled) {
+			isWebCamEnabled = webCamEnabled;
+			return this;
+		}
+
+		public ComputerBuilder setTouchScreenEnabled(boolean touchScreenEnabled) {
+			isTouchScreenEnabled = touchScreenEnabled;
+			return this;
+		}
+
+		public Computer build(){
+			return new Computer(this);
+		}
+	}
+
+	@Override
+	public String toString() {
+		return "Computer{" +
+				"HDD='" + HDD + '\'' +
+				", RAM='" + RAM + '\'' +
+				", screenSize='" + screenSize + '\'' +
+				", isGraphicsCardEnabled=" + isGraphicsCardEnabled +
+				", isBluetoothEnabled=" + isBluetoothEnabled +
+				", isWebCamEnabled=" + isWebCamEnabled +
+				", isTouchScreenEnabled=" + isTouchScreenEnabled +
+				'}';
+	}
+}

Java Design Patterns/javadevjournal/design/creational/factory/Circle.java

@@ -0,0 +1,11 @@
+package javadevjournal.design.creational.factory;
+
+/**
+ * @author Kunwar
+ */
+public class Circle implements Shape {
+   @Override
+   public void drawShape() {
+      System.out.println("Inside Circle::drawShape() method.");
+   }
+}

Java Design Patterns/javadevjournal/design/creational/factory/FactoryPatternDemo.java

@@ -0,0 +1,23 @@
+package javadevjournal.design.creational.factory;
+
+/**
+ * @author Kunwar
+ * Factory Pattern Demo
+ */
+public class FactoryPatternDemo {
+   public static void main(String[] args) {
+      ShapeFactory shapeFactory = new ShapeFactory();
+
+      /* get an object of Circle Class and call its drawShape method. */
+      Shape shape1 = shapeFactory.getShape("CIRCLE");
+      shape1.drawShape();
+
+      /* get an object of Rectangle Class and call its drawShape method. */
+      Shape shape2 = shapeFactory.getShape("RECTANGLE");
+      shape2.drawShape();
+
+      /* get an object of Square Class and call its drawShape method. */
+      Shape shape3 = shapeFactory.getShape("SQUARE");
+      shape3.drawShape();
+   }
+}

Java Design Patterns/javadevjournal/design/creational/factory/Rectangle.java

@@ -0,0 +1,11 @@
+package javadevjournal.design.creational.factory;
+
+/**
+ * @author Kunwar
+ */
+public class Rectangle implements Shape {
+   @Override
+   public void drawShape() {
+      System.out.println("Inside Rectangle::drawShape() method.");
+   }
+}

Java Design Patterns/javadevjournal/design/creational/factory/Shape.java

@@ -0,0 +1,8 @@
+package javadevjournal.design.creational.factory;
+
+/**
+ * @author Kunwar
+ */
+public interface Shape {
+   void drawShape();
+}

Java Design Patterns/javadevjournal/design/creational/factory/ShapeFactory.java

@@ -0,0 +1,28 @@
+package javadevjournal.design.creational.factory;
+
+/**
+ * @author Kunwar
+ * Factory Pattern Implementation here
+ */
+public class ShapeFactory {
+   /**
+    * get the shapeType from caller and decide the correct implementation class
+    * @param shapeType
+    * @return
+    */
+   public Shape getShape(String shapeType){
+      if(shapeType == null){
+         return null;
+      }		
+      if(shapeType.equalsIgnoreCase("CIRCLE")){
+         return new Circle();
+         
+      } else if(shapeType.equalsIgnoreCase("RECTANGLE")){
+         return new Rectangle();
+         
+      } else if(shapeType.equalsIgnoreCase("SQUARE")){
+         return new Square();
+      }
+      return null;
+   }
+}

Java Design Patterns/javadevjournal/design/creational/factory/Square.java

@@ -0,0 +1,11 @@
+package javadevjournal.design.creational.factory;
+
+/**
+ * @author Kunwar
+ */
+public class Square implements Shape {
+   @Override
+   public void drawShape() {
+      System.out.println("Inside Square::drawShape() method.");
+   }
+}

Java Design Patterns/javadevjournal/design/creational/factory/banking/BankAccount.java

@@ -0,0 +1,8 @@
+package javadevjournal.design.creational.factory.banking;
+
+/**
+ * @author Kunwar
+ */
+public interface BankAccount {
+    public void registerAccount();
+}

Java Design Patterns/javadevjournal/design/creational/factory/banking/BankAccountFactory.java

@@ -0,0 +1,20 @@
+package javadevjournal.design.creational.factory.banking;
+
+/**
+ * @author Kunwar
+ */
+public class BankAccountFactory {
+    public BankAccount createAccount(String type){
+        BankAccount bankAccount = null;
+        if (type.equals("P")){
+            bankAccount = new PersonalAccount();
+        } else if (type.equals("B")){
+            bankAccount = new BusinessAccount();
+        } else if (type.equals("C")){
+            bankAccount = new CheckingAccount();
+        } else {
+            System.out.println("Invalid type");
+        }
+        return bankAccount;
+    }
+}

Java Design Patterns/javadevjournal/design/creational/factory/banking/Branch.java

@@ -0,0 +1,22 @@
+package javadevjournal.design.creational.factory.banking;
+
+import java.util.Scanner;
+
+/**
+ * @author Kunwar
+ */
+public class Branch {
+    public static void main(String[] args) {
+        BankAccount bankAccount = null;
+        BankAccountFactory bankAccountFactory = new BankAccountFactory();
+        Scanner in = new Scanner(System.in);
+        System.out.println("Please enter\n" +
+                " P for Personal account\n" +
+                " B for Business account\n" +
+                " C for Checking account\n" +
+                "----------------------------");
+        String accountType = in.nextLine();
+        bankAccount = bankAccountFactory.createAccount(accountType);
+        bankAccount.registerAccount();;
+    }
+}

Java Design Patterns/javadevjournal/design/creational/factory/banking/BusinessAccount.java

@@ -0,0 +1,11 @@
+package javadevjournal.design.creational.factory.banking;
+
+/**
+ * @author Kunwar
+ */
+public class BusinessAccount implements BankAccount {
+    @Override
+    public void registerAccount() {
+        System.out.println("Creating a business account");
+    }
+}

Java Design Patterns/javadevjournal/design/creational/factory/banking/CheckingAccount.java

@@ -0,0 +1,11 @@
+package javadevjournal.design.creational.factory.banking;
+
+/**
+ * @author Kunwar
+ */
+public class CheckingAccount implements BankAccount{
+    @Override
+    public void registerAccount() {
+        System.out.println("Creating a checking account");
+    }
+}

Java Design Patterns/javadevjournal/design/creational/factory/banking/PersonalAccount.java

@@ -0,0 +1,11 @@
+package javadevjournal.design.creational.factory.banking;
+
+/**
+ * @author Kunwar
+ */
+public class PersonalAccount implements BankAccount{
+    @Override
+    public void registerAccount() {
+        System.out.println("Creating a personal account");
+    }
+}

Java Design Patterns/javadevjournal/design/creational/singleton/Singleton.java

@@ -0,0 +1,18 @@
+package javadevjournal.design.creational.singleton;
+
+/**
+ * @author Kunwar
+ */
+public class Singleton {
+
+   /* private instance variable  */
+   private static Singleton instance = new Singleton();
+
+   /* private constructor */
+   private Singleton(){}
+
+   /* returns the same object */
+   public static Singleton getInstance(){
+      return instance;
+   }
+}

Java Design Patterns/javadevjournal/design/creational/singleton/SingletonMultiThreaded.java

@@ -0,0 +1,23 @@
+package javadevjournal.design.creational.singleton;
+
+public class SingletonMultiThreaded {
+
+    /* private instance variable  */
+    private static volatile SingletonMultiThreaded INSTANCE;
+  
+    /* private constructor */
+    private SingletonMultiThreaded() { }
+
+    public static SingletonMultiThreaded getInstance() {
+        /* double-checking lock */
+        if(null == INSTANCE){
+            /* synchronized block */
+            synchronized (SingletonMultiThreaded.class) {
+                if(null == INSTANCE){
+                    INSTANCE = new SingletonMultiThreaded();
+                }
+            }
+        }
+        return INSTANCE;
+    }
+}

Java Design Patterns/javadevjournal/design/creational/singleton/SingletonPatternDemo.java

@@ -0,0 +1,24 @@
+package javadevjournal.design.creational.singleton;
+
+/**
+ * @author Kunwar
+ */
+public class SingletonPatternDemo {
+   public static void main(String[] args) {
+      /* Let's create 3 objects and see their hashcode and they will be same. */
+      System.out.println("in single threaded environment");
+      Singleton singleton1 = Singleton.getInstance();
+      Singleton singleton2 = Singleton.getInstance();
+      Singleton singleton3 = Singleton.getInstance();
+      System.out.println(singleton1.hashCode() +" "+ singleton2.hashCode() +" "+ singleton3.hashCode());
+
+      System.out.println("in multi threaded environment");
+      Thread1 t1 = new Thread1();
+      t1.run();
+      Thread2 t2 = new Thread2();
+      t2.run();
+      Thread3 t3 = new Thread3();
+      t3.run();
+
+   }
+}

Java Design Patterns/javadevjournal/design/creational/singleton/Thread1.java

@@ -0,0 +1,9 @@
+package javadevjournal.design.creational.singleton;
+
+public class Thread1 implements  Runnable{
+    @Override
+    public void run() {
+        SingletonMultiThreaded singletonMultiThreaded = SingletonMultiThreaded.getInstance();
+        System.out.print(singletonMultiThreaded.hashCode() + " ");
+    }
+}

Java Design Patterns/javadevjournal/design/creational/singleton/Thread2.java

@@ -0,0 +1,9 @@
+package javadevjournal.design.creational.singleton;
+
+public class Thread2 implements  Runnable{
+    @Override
+    public void run() {
+        SingletonMultiThreaded singletonMultiThreaded = SingletonMultiThreaded.getInstance();
+        System.out.print(singletonMultiThreaded.hashCode() + " ");
+    }
+}

Java Design Patterns/javadevjournal/design/creational/singleton/Thread3.java

@@ -0,0 +1,9 @@
+package javadevjournal.design.creational.singleton;
+
+public class Thread3 implements  Runnable{
+    @Override
+    public void run() {
+        SingletonMultiThreaded singletonMultiThreaded = SingletonMultiThreaded.getInstance();
+        System.out.println(singletonMultiThreaded.hashCode());
+    }
+}

Java Design Patterns/javadevjournal/design/creational/singleton/breakit/BreakSingletonUsingReflection.java

@@ -0,0 +1,27 @@
+package javadevjournal.design.creational.singleton.breakit;
+
+import java.lang.reflect.Constructor;
+
+/**
+ * @author Kunwar
+ */
+public class BreakSingletonUsingReflection {
+    public static void main(String[] args) {
+        Singleton singleton1 = Singleton.instance;
+        Singleton singleton2 = null;
+        try {
+            Constructor[] constructors =
+                    Singleton.class.getDeclaredConstructors();
+            for (Constructor constructor : constructors) {
+                // Below code will destroy the singleton pattern
+                constructor.setAccessible(true);
+                singleton2 = (Singleton) constructor.newInstance();
+                break;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        System.out.println("instance1.hashCode(): " + singleton1.hashCode());
+        System.out.println("instance2.hashCode(): " + singleton2.hashCode());
+    }
+}

Java Design Patterns/javadevjournal/design/creational/singleton/breakit/Singleton.java

@@ -0,0 +1,10 @@
+package javadevjournal.design.creational.singleton.breakit;
+
+/**
+ * @author Kunwar
+ */
+class Singleton{
+    public static Singleton instance = new Singleton();
+    private Singleton() {
+    }
+}

Java Design Patterns/javadevjournal/design/structural/adapter/AdapterPatternDemo.java

@@ -0,0 +1,14 @@
+package javadevjournal.design.structural.adapter;
+
+/**
+ * @author Kunwar
+ */
+public class AdapterPatternDemo {
+   public static void main(String[] args) {
+      AudioPlayer audioPlayer = new AudioPlayer();
+      audioPlayer.playMusic("mp3", "song1.mp3");
+      audioPlayer.playMusic("mp4", "song2.mp4");
+      audioPlayer.playMusic("vlc", "song3.vlc");
+      audioPlayer.playMusic("xyz", "song4.avi");
+   }
+}

Java Design Patterns/javadevjournal/design/structural/adapter/AdvancedMediaPlayer.java

@@ -0,0 +1,9 @@
+package javadevjournal.design.structural.adapter;
+
+/**
+ * @author Kunwar
+ */
+public interface AdvancedMediaPlayer {
+   void playVlcPlayer(String fileName);
+   void playMp4Player(String fileName);
+}

Java Design Patterns/javadevjournal/design/structural/adapter/AudioPlayer.java

@@ -0,0 +1,22 @@
+package javadevjournal.design.structural.adapter;
+
+/**
+ * @author Kunwar
+ */
+public class AudioPlayer implements MediaPlayer {
+   private MediaAdapter mediaAdapter;
+   @Override
+   public void playMusic(String audioType, String fileName) {
+      //the mp3 format is supported by AudioPlayer itself and it doesn't need adapter here.
+      if(audioType.equalsIgnoreCase("mp3")){
+         System.out.println("Playing mp3 file: " + fileName);
+      }
+      //to support other formats, we will need the MediaAdapter
+      else if(audioType.equalsIgnoreCase("vlc") || audioType.equalsIgnoreCase("mp4")){
+         mediaAdapter = new MediaAdapter(audioType);
+         mediaAdapter.playMusic(audioType, fileName);
+      }else{
+         System.out.println("The given format: " + audioType + " is not supported");
+      }
+   }   
+}

Java Design Patterns/javadevjournal/design/structural/adapter/MediaAdapter.java

@@ -0,0 +1,28 @@
+package javadevjournal.design.structural.adapter;
+
+/**
+ * @author Kunwar
+ */
+public class MediaAdapter implements MediaPlayer {
+
+   public static final String VLC = "vlc";
+   public static final String MP_4 = "mp4";
+
+   private AdvancedMediaPlayer advancedMusicPlayer;
+   public MediaAdapter(String audioType){
+      if(audioType.equalsIgnoreCase(VLC) ){
+         advancedMusicPlayer = new VlcMusicPlayer();
+      }else if (audioType.equalsIgnoreCase(MP_4)){
+         advancedMusicPlayer = new Mp4MusicPlayer();
+      }	
+   }
+
+   @Override
+   public void playMusic(String audioType, String fileName) {
+      if(audioType.equalsIgnoreCase(VLC)){
+         advancedMusicPlayer.playVlcPlayer(fileName);
+      }else if(audioType.equalsIgnoreCase(MP_4)){
+         advancedMusicPlayer.playMp4Player(fileName);
+      }
+   }
+}

Java Design Patterns/javadevjournal/design/structural/adapter/MediaPlayer.java

@@ -0,0 +1,8 @@
+package javadevjournal.design.structural.adapter;
+
+/**
+ * @author Kunwar
+ */
+public interface MediaPlayer{
+   void playMusic(String audioType, String fileName);
+}

Java Design Patterns/javadevjournal/design/structural/adapter/Mp4MusicPlayer.java

@@ -0,0 +1,17 @@
+package javadevjournal.design.structural.adapter;
+
+/**
+ * @author Kunwar
+ */
+public class Mp4MusicPlayer implements AdvancedMediaPlayer{
+
+   @Override
+   public void playVlcPlayer(String fileName) {
+      //do nothing
+   }
+
+   @Override
+   public void playMp4Player(String fileName) {
+      System.out.println("Playing mp4 file: "+ fileName);
+   }
+}

Java Design Patterns/javadevjournal/design/structural/adapter/VlcMusicPlayer.java

@@ -0,0 +1,16 @@
+package javadevjournal.design.structural.adapter;
+
+/**
+ * @author Kunwar
+ */
+public class VlcMusicPlayer implements AdvancedMediaPlayer{
+   @Override
+   public void playVlcPlayer(String fileName){
+      System.out.println("Playing vlc file: "+ fileName);
+   }
+
+   @Override
+   public void playMp4Player(String fileName) {
+      //do nothing
+   }
+}

Java Design Patterns/javadevjournal/ds/avl/AVLNode.java

@@ -0,0 +1,22 @@
+package javadevjournal.ds.avl;
+
+class AVLNode{
+
+    AVLNode left, right;
+    int data;
+    int height;
+
+    public AVLNode(){
+        left = null;
+        right = null;
+        data = 0;
+        height = 0;
+    }
+
+    public AVLNode(int n){
+        left = null;
+        right = null;
+        data = n;
+        height = 0;
+    }
+}

Java Design Patterns/javadevjournal/ds/avl/AVLTree.java

@@ -0,0 +1,195 @@
+package javadevjournal.ds.avl;
+
+class AVLTree{
+    private AVLNode root;
+    public AVLTree(){
+        root = null;
+    }
+
+
+    /**
+     *
+     * @param avlNode
+     * @return
+     */
+    private int height(AVLNode avlNode ){
+        return avlNode == null ? -1 : avlNode.height;
+    }
+
+    /**
+     *
+     * @param lHeight
+     * @param rHeight
+     * @return
+     */
+    private int max(int lHeight, int rHeight){
+        return lHeight > rHeight ? lHeight : rHeight;
+    }
+
+    /**
+     *
+     * @param data
+     */
+    public void insert(int data){
+        root = insert(data, root);
+    }
+
+
+    /**
+     *
+     * @param data
+     * @param avlNode
+     * @return
+     */
+    private AVLNode insert(int data, AVLNode avlNode)
+    {
+        if (avlNode == null)
+            avlNode = new AVLNode(data);
+        else if (data < avlNode.data){
+            avlNode.left = insert( data, avlNode.left );
+            if( height( avlNode.left ) - height( avlNode.right ) == 2 )
+                if( data < avlNode.left.data )
+                    avlNode = leftRotation( avlNode );
+                else
+                    avlNode = leftRightRotation( avlNode );
+        }
+        else if( data > avlNode.data ){
+            avlNode.right = insert( data, avlNode.right );
+            if( height( avlNode.right ) - height( avlNode.left ) == 2 )
+                if( data > avlNode.right.data)
+                    avlNode = rightRotation( avlNode );
+                else
+                    avlNode = rightLeftRotation( avlNode );
+        }
+        else
+            ;  // Duplicate; do nothing
+        avlNode.height = max( height( avlNode.left ), height( avlNode.right ) ) + 1;
+        return avlNode;
+    }
+
+    /**
+     *
+     * @param avlNode
+     * @return
+     */
+    private AVLNode leftRotation(AVLNode avlNode){
+        AVLNode k1 = avlNode.left;
+        avlNode.left = k1.right;
+        k1.right = avlNode;
+        avlNode.height = max( height( avlNode.left ), height( avlNode.right ) ) + 1;
+        k1.height = max( height( k1.left ), avlNode.height ) + 1;
+        return k1;
+    }
+
+
+    /**
+     *
+     * @param avlNode
+     * @return
+     */
+    private AVLNode rightRotation(AVLNode avlNode){
+        AVLNode node = avlNode.right;
+        avlNode.right = node.left;
+        node.left = avlNode;
+        avlNode.height = max( height( avlNode.left ), height( avlNode.right ) ) + 1;
+        node.height = max( height( node.right ), avlNode.height ) + 1;
+        return node;
+    }
+    /**
+     * left-right rotation
+     * @param avlNode
+     * @return
+     */
+    private AVLNode leftRightRotation(AVLNode avlNode){
+        avlNode.left = rightRotation( avlNode.left );
+        return leftRotation( avlNode );
+    }
+
+    /**
+     * right-left rotation
+     * @param avlNode
+     * @return
+     */
+    private AVLNode rightLeftRotation(AVLNode avlNode)
+    {
+        avlNode.right = leftRotation( avlNode.right );
+        return rightRotation( avlNode );
+    }
+
+    /**
+     *
+     * @return
+     */
+    public int countNodes(){
+        return countNodes(root);
+    }
+
+    /**
+     *
+     * @param avlNode
+     * @return
+     */
+    private int countNodes(AVLNode avlNode){
+        if (avlNode == null)
+            return 0;
+        else{
+            int l = 1;
+            l += countNodes(avlNode.left);
+            l += countNodes(avlNode.right);
+            return l;
+        }
+    }
+
+    /**
+     *
+     * @param data
+     * @return
+     */
+    public boolean search(int data){
+        return search(root, data);
+    }
+
+    /**
+     *
+     * @param avlNode
+     * @param data
+     * @return
+     */
+    private boolean search(AVLNode avlNode, int data){
+        boolean found = false;
+        while ((avlNode != null) && !found)
+        {
+            int rval = avlNode.data;
+            if (data < rval)
+                avlNode = avlNode.left;
+            else if (data > rval)
+                avlNode = avlNode.right;
+            else
+            {
+                found = true;
+                break;
+            }
+            found = search(avlNode, data);
+        }
+        return found;
+    }
+
+    /**
+     *
+     */
+    public void inorder(){
+        inorder(root);
+    }
+
+    /**
+     *
+     * @param avlNode
+     */
+    private void inorder(AVLNode avlNode){
+        if (avlNode != null){
+            inorder(avlNode.left);
+            System.out.print(avlNode.data +" ");
+            inorder(avlNode.right);
+        }
+    }
+}

Java Design Patterns/javadevjournal/ds/avl/AVLTreeHelper.java

@@ -0,0 +1,42 @@
+package javadevjournal.ds.avl;
+
+import java.util.Scanner;
+
+public class AVLTreeHelper{
+    public static void main(String[] args){
+        Scanner scanner = new Scanner(System.in);
+        AVLTree avlTree = new AVLTree();
+
+        char ch;
+        do{
+            System.out.println("\nAVLTree Operations\n");
+            System.out.println("1. insert ");
+            System.out.println("2. search");
+            System.out.println("3. count nodes");
+            int choice = scanner.nextInt();
+            switch (choice)
+            {
+                case 1 :
+                    System.out.println("Enter integer element to insert");
+                    avlTree.insert( scanner.nextInt() );
+                    break;
+                case 2 :
+                    System.out.println("Enter integer element to search");
+                    System.out.println("Search result : "+ avlTree.search( scanner.nextInt()));
+                    break;
+                case 3 :
+                    System.out.println("Nodes = "+ avlTree.countNodes());
+                    break;
+                default :
+                    System.out.println("Wrong Entry \n ");
+                    break;
+            }
+
+            System.out.print("\nIn order : ");
+            avlTree.inorder();
+
+            System.out.println("\nDo you want to continue (Type y or n) \n");
+            ch = scanner.next().charAt(0);
+        } while (ch == 'Y'|| ch == 'y');
+    }
+}