updated

Author: Chaklader

.DS_Store

@@ -1,6 +1,9 @@
 package design.design_patterns.adapter.PaymentSys;
 
+
+
 public interface PayD {
+
 
 	public String getCustCardNo();
 
@@ -12,13 +15,11 @@ public interface PayD {
 
 	public Double getTotalAmount();
 
-	public void setCustCardNo(String custCardNo);
 
-	public void setCardOwnerName(String cardOwnerName);
 
+	public void setCustCardNo(String custCardNo);
+	public void setCardOwnerName(String cardOwnerName);
 	public void setCardExpMonthDate(String cardExpMonthDate);
-
 	public void setCVVNo(Integer cVVNo);
-
 	public void setTotalAmount(Double totalAmount);
 }

Design_Patterns/Adapter/PaymentSystem/PayD.java

@@ -1,12 +1,43 @@
 package design.design_patterns.adapter.PaymentSys;
 
 
+
+/*
+A software developer, Max, has worked on an e-commerce website. The website allows users 
+to shop and pay online. The site is integrated with a 3rd party payment gateway, through 
+which users can pay their bills using their credit card. Everything was going well, until 
+his manager called him for a change in the project.
+
+	The manager told him that they are planning to change the payment gateway vendor, and he 
+	has to implement that in the code.
+
+The problem that arises here is that the site is attached to the Xpay payment gateway which 
+takes an Xpay type of object. The new vendor, PayD, only allows the PayD type of objects 
+to allow the process. Max doesn’t want to change the whole set of 100 of classes which have 
+reference to an object of type XPay. This also raises the risk on the project, which is 
+already running on the production. Neither he can change the 3rd party tool of the payment 
+gateway. The problem has occurred due to the incompatible interfaces between the two different 
+parts of the code. In order to get the process work, Max needs to find a way to make the 
+code compatible with the vendor’s provided API.
+*/
+
 public class RunAdapterExample {
 
+
+	private static void testPayD(PayD payD){
+		
+		System.out.println(payD.getCardOwnerName());
+		System.out.println(payD.getCustCardNo());
+		System.out.println(payD.getCardExpMonthDate());
+		System.out.println(payD.getCVVNo());
+		System.out.println(payD.getTotalAmount());
+	}
+
 	public static void main(String[] args) {
 
 		// Object for Xpay
 		Xpay xpay = new XpayImpl();
+
 		xpay.setCreditCardNo("4789565874102365");
 		xpay.setCustomerName("Max Warner");
 		xpay.setCardExpMonth("09");
@@ -17,14 +48,4 @@ public static void main(String[] args) {
 		PayD payD = new XpayToPayDAdapter(xpay);
 		testPayD(payD);
 	}
-	
-	private static void testPayD(PayD payD){
-		
-		System.out.println(payD.getCardOwnerName());
-		System.out.println(payD.getCustCardNo());
-		System.out.println(payD.getCardExpMonthDate());
-		System.out.println(payD.getCVVNo());
-		System.out.println(payD.getTotalAmount());
-	}
-
 }

Design_Patterns/Adapter/PaymentSystem/RunAdapterExample.java

@@ -4,6 +4,7 @@
 
 public class XpayImpl implements Xpay{
 
+
 	private String creditCardNo;
 	private String customerName;
 	private String cardExpMonth;
@@ -70,5 +71,4 @@ public void setCardCVVNo(Short cardCVVNo) {
 	public void setAmount(Double amount) {
 		this.amount = amount;
 	}
-
 }

Design_Patterns/Adapter/PaymentSystem/XpayImpl.java

@@ -16,10 +16,16 @@ public XpayToPayDAdapter(Xpay xpay){
 		setProp();
 	}
 
-	
+	// public void setCustCardNo(String custCardNo);
+	// public void setCardOwnerName(String cardOwnerName);
+	// public void setCardExpMonthDate(String cardExpMonthDate);
+	// public void setCVVNo(Integer cVVNo);
+	// public void setTotalAmount(Double totalAmount);
+
 	private void setProp(){
-		setCardOwnerName(this.xpay.getCustomerName());
+
 		setCustCardNo(this.xpay.getCreditCardNo());
+		setCardOwnerName(this.xpay.getCustomerName());
 		setCardExpMonthDate(this.xpay.getCardExpMonth()+"/"+this.xpay.getCardExpYear());
 		setCVVNo(this.xpay.getCardCVVNo().intValue());
 		setTotalAmount(this.xpay.getAmount());

Design_Patterns/Adapter/PaymentSystem/XpayToPayDAdapter.java

@@ -1,7 +1,50 @@
 package com.car;
 
+
+/*
+Sec Security System is a security and electronic company which produces and assembles 
+products for cars. It delivers any car electronic or security system you want, from 
+air bags to GPS tracking system, reverse parking system etc. Big car companies use 
+its products in their cars. The company uses a well defined object oriented approach 
+to keep track of their products using software which is developed and maintained by 
+them only. They get the car, produce the system for it and assemble it into the car.
+
+Recently, they got new orders from BigWheel (a car company) to produce central locking 
+and gear lock system for their new xz model. To maintain this, they are creating a new 
+software system. They started by creating a new abstract class CarProductSecurity, in 
+which they kept some car specific methods and some of the features which they thought 
+are common to all security products. Then they extended the class and created two 
+different sub classes named them BigWheelXZCentralLocking, and BigWheelXZGearLocking.
+
+
+After a while, another car company Motoren asked them to produce a new system of central 
+locking and gear lock for their lm model. Since, the same security system cannot be used 
+in both models of different cars, the Sec Security System has produced the new system for 
+them, and also has created to new classes MotorenLMCentralLocking, and MotorenLMGearLocking 
+which also extend the CarProductSecurity class.
+
+
+
+Use of Bridge Pattern
+---------------------
+
+You want to avoid a permanent binding between an abstraction and its implementation. This might 
+be the case, for example, when the implementation must be selected or switched at run-time.
+
+Both the abstractions and their implementations should be extensible by sub-classing. In this 
+case, the Bridge pattern lets you combine the different abstractions and implementations and 
+extend them independently.
+
+Changes in the implementation of an abstraction should have no impact on clients; that is, their 
+code should not have to be recompiled.
+
+You want to share an implementation among multiple objects (perhaps using reference counting), 
+and this fact should be hidden from the client.
+*/
 public class App{
 
+
+
    public static void main( String[] args ){
 
    	    System.out.println();

Design_Patterns/Bridge/CarAccessories/App.java

@@ -14,8 +14,8 @@ public Car(Product product,String carType){
 		this.carType = carType;
 	}
 
-	public abstract void assemble();
 	public abstract void produceProduct();
+	public abstract void assemble();
 
 	public void printDetails(){
 		System.out.println("Car: "+carType+", Product:"+product.productName());

Design_Patterns/Bridge/CarAccessories/Car.java

@@ -3,7 +3,6 @@
 
 public class HtmlElement extends HtmlTag {
 
-
     private String tagName;
     private String startTag;
     private String endTag;
@@ -40,4 +39,5 @@ public void setTagBody(String tagBody) {
     public void generateHtml() {
         System.out.println(startTag + "" + tagBody + "" + endTag);
     }
-}
+}
+

Design_Patterns/Composite/HtmlTags/HtmlElement.java

@@ -6,12 +6,16 @@
 
 public class HtmlParentElement extends HtmlTag {
 
+
 	private String tagName;
 	private String startTag;
 	private String endTag;
+
 	private List<HtmlTag> childrenTag;
 
+
 	public HtmlParentElement(String tagName){
+
 		this.tagName = tagName;
 		this.startTag = "";
 		this.endTag = "";
@@ -50,11 +54,13 @@ public void removeChildTag(HtmlTag htmlTag){
 
 	@Override
 	public void generateHtml() {
+	
 		System.out.println(startTag);
+	
 		for(HtmlTag tag : childrenTag){
 			tag.generateHtml();
 		}
-		System.out.println(endTag);
 
+		System.out.println(endTag);
 	}
 }

Design_Patterns/Composite/HtmlTags/HtmlParentElement.java

@@ -1,16 +1,8 @@
 package design.design_patterns.composite.htmltags;
 
-
-/*The Composite Pattern has four participants:
----------------------------------------------	
-1. Component
-2. Leaf
-3. Composite
-4. Client
---------------------------------------------*/
-
 import java.util.List;
 
+
 public abstract class HtmlTag {
 
     public abstract String getTagName();

Design_Patterns/Composite/HtmlTags/HtmlTag.java

@@ -1,6 +1,52 @@
 package design.design_patterns.composite.htmltags;
 
+/*
+Composite Pattern
+-----------------
+
+The English meaning of the word Composite is something that is made up of complicated and related 
+parts. The composite means “putting together” and this is what this design pattern is all about.
+
+There are times when you feel a need of a tree data structure in your code. There are many variations 
+to the tree data structure, but sometimes there is a need of a tree in which both branches as well 
+as leafs of the tree should be treated as uniformly.
+
+The Composite Pattern allows you to compose objects into a tree structure to represent the part-whole 
+hierarchy which means you can create a tree of objects that is made of different parts, but that 
+can be treated as a whole one big thing. Composite lets clients to treat individual objects and 
+compositions of objects uniformly, that’s the intent of the Composite Pattern.
+
+There can be lots of practical examples of the Composite Pattern. A file directory system, an html 
+representation in java, an XML parser all are well managed composites and all can easily be represented 
+using the Composite Pattern. But before digging into the details of an example, let’s see some 
+more details regarding the Composite Pattern.
+
+
+The formal definition of the Composite Pattern says that it allows you to compose objects into tree 
+structures to represent part-whole hierarchies. Composite lets clients to treat individual objects 
+and compositions of objects uniformly.
 
+If you are familiar with a tree data structure, you will know a tree has parents and their children. 
+There can be multiple children to a parent, but only one parent per child. In Composite Pattern, 
+elements with children are called as Nodes, and elements without children are called as Leafs.
+
+The Composite Pattern allows us to build structures of objects in the form of trees that contains 
+both composition of objects and individual objects as nodes. Using a composite structure, we can 
+apply the same operations over both composites and individual objects. In other words, in most 
+cases we can ignore the differences between compositions of objects and individual objects.
+
+
+
+The Composite Pattern has four participants:
+
+    Component
+
+    Leaf
+    
+    Composite
+    
+    Client
+*/
 public class TestCompositePattern {
 
 /*
@@ -16,6 +62,7 @@ public class TestCompositePattern {
     </html>
 */    
 
+
     public static void main(String[] args) {
 
         // parent elements

Design_Patterns/Composite/HtmlTags/TestCompositePattern.java

@@ -1,8 +1,78 @@
 package com.javacodegeeks.patterns.facadepattern;
 
+
+
+/*
+
+Your company is a product based company and it has launched a product in the market, named 
+Schedule Server. It is a kind of server in itself, and it is used to manage jobs. The jobs 
+could be any kind of jobs like sending a list of emails, sms, reading or writing files from 
+a destination, or just simply transferring files from a source to the destination. The product 
+is used by the developers to manage such kind of jobs and able to concentrate more towards 
+their business goal. The server executes each job at their specified time and also manages 
+all underline issues like concurrency issue and security by itself. As a developer, one just 
+need to code only the relevant business requirements and a good amount of API calls is provided 
+to schedule a job according to their needs.
+
+Everything was going fine, until the clients started complaining about starting and stopping 
+the process of the server. They said, although the server is working great, the initializing 
+and the shutting down processes are very complex and they want an easy way to do that. The 
+server has exposed a complex interface to the clients which looks a bit hectic to them.
+
+We need to provide an easy way to start and stop the server.
+
+A complex interface to the client is already considered as a fault in the design of the current 
+system. But fortunately or unfortunately, we cannot start the designing and the coding from 
+scratch. We need a way to resolve this problem and make the interface easy to access.
+
+
+
+Facade Pattern
+--------------
+
+The Facade Pattern makes a complex interface easier to use, using a Facade class. The Facade 
+Pattern provides a unified interface to a set of interface in a subsystem. Facade defines a 
+higher-level interface that makes the subsystem easier to use.
+
+The Facade unifies the complex low-level interfaces of a subsystem in-order to provide a simple 
+way to access that interface. It just provides a layer to the complex interfaces of the sub-system 
+which makes it easier to use.
+
+
+A Facade is not just only able to simplify an interface, but it also decouples a client from a 
+subsystem. It adheres to the Principle of Least Knowledge, which avoids tight coupling between 
+the client and the subsystem. This provides flexibility: suppose in the above problem, the company 
+wants to add some more steps to start or stop the Schedule Server, that have their own different 
+interfaces. If you coded your client code to the facade rather than the subsystem, your client 
+code doesn’t need to be change, just the facade required to be changed, that’s would be delivered 
+with a new version to the client.
+
+
+
+Usage of the Facade Pattern
+---------------------------
+
+i.  You want to provide a simple interface to a complex subsystem. Subsystems often get more 
+	complex as they evolve. Most patterns, when applied, result in more and smaller classes. This 
+	makes the subsystem more reusable and easier to customize, but it also becomes harder to use 
+	for clients that don’t need to customize it. A facade can provide a simple default view of the 
+	subsystem that is good enough for most clients. Only clients needing more customizability will 
+	need to look beyond the facade.
+
+ii. There are many dependencies between clients and the implementation classes of an abstraction. 
+	Introduce a facade to decouple the subsystem from clients and other subsystems, thereby promoting 
+	subsystem independence and portability.
+
+iii. You can layer your subsystems. Use a facade to define an entry point to each subsystem level. 
+	 If subsystems are dependent, then you can simplify the dependencies between them by making them 
+	 communicate with each other solely through their facades.
+*/
+
+
 public class RunServer {
 
 
+
 	public static void main(String[] args) {
 
 		ScheduleServer scheduleServer = new ScheduleServer();