Skip to main content
Java Design

Java Design Pattern v1.1

Overview :

Design patterns, speaking generically, are language-independent, (i.e. Java/C# etc.) strategies for solving common object-oriented design problems. We can summarize this to say that design patterns are provided  to ensure Industry standard levels and to solve iteration issues. They also provide the best solution for developers to develop the industry-base application .

Some benefits of design patterns:

  • Patterns are generally a close-at-hand way to represent ideas.
  • Patterns do have binding to programming paradigm(Oops programming).
  • Pattern is appropriate for given problem/architecture/task and therefore you can implement it in any language — let it be Java , C# or Python etc.
  • You can easily learn how to avoid silly mistakes in  your code application.
  • Patterns help you to decide which solution is the best by providing you a set of good solutions to these common problems.

When should we use design patterns?

Design pattern should we use during the analysis and requirement phase of SDLC.

How many design patterns are available in java?

Java offers creationalstructural, and behavioral design patterns.These patters again divide into different patterns.

Let me explain this in more detail:

Creational Design Patterns:  Creational Design Patterns provide the way to create ab objects (instantiate an object) for a specific situation. That means the developer should think before he creates the object.

Types of Creational Design Patterns:

(a) Singleton Pattern: Only one instance of the class exists in the JVM. The Singleton pattern has different-2 approach like Eager\Lazy\Static block initialization, Enum, Reflection concept and Serialization Singleton etc. For example:

package com.trigentDesignpattern.singleton; public enum EnumTrigentSingleton {     INSTANCE;     public static void doTrigentContent(){         //do something     }
}

(b) Prototype Pattern: Many instance of the class exists in the JVM and we can say the prototype results in a cloned object which is different from the original object. It is very useful in dynamic binding(classes to instantiate are specified at run time). Its improve the performance of the application because its used cloning concept. For example:

public interface TrigentPrototype {Public abstract Object Clone();}  public class TrigentClone implements TrigentPrototype { public Object Clone(){ Return super.Clone();}}   
public class Clone{
   Public static void main(String args[]){
       TrigentClone obj1 = new TrigentClone ();
       TrigentClone obj2 = (TrigentClone)obj1.Clone();
   }
}

(c) Abstract Factory Pattern: Abstract factory is normally used for things like dependency injection and strategy concept, when we want to be able to create a whole family of objects that need to be of  “the same kind”,  and have some common base classes. For example:

interface TrigentFactory {
  Plant makeTrigentPlant();
  Picker makeTrigentPicker(); 
}
public class TrigentAppleFactory implements TrigentFactory {
  Plant makeTrigentPlant() {
    return new Apple();
  }
}
public class TrigentOrangeFactory implements TrigentFactory {
  Plant makeTrigentPlant() {
return new Orange(); 
 }
 }

(d) Factory Pattern:

Creates objects based on input criteria and without showing the instantiate logic to the client.  The Factory Pattern is used when we have some generic processing in a class. For example:

 

interface TrigentFactory {
  public Apple makeApple() { // Code for creating an Apple here. } }
 abstract class TrigentFruitPicker {
  protected abstract Fruit makeFruit();
  public void pickFruit() {
    private final Fruit f = makeFruit(); // The fruit we will work on..
    }}
class ApplePicker extends TrigentFruitPicker {
  @Override
  protected Fruit makeFruit() {
    return new makeApple();
  }
}

(e) Builder Pattern:  Builder Pattern used for recurring\iterate generic processing. Make and return one object into various ways (Parse a complex representation, create one of several targets). Its reduce the number of parameters in the Method\Constructor via the custom types\parameters object.

Monu Kumar

Monu Kumar

Monu Kumar works as Software Engineer with Trigent Software. He has nearly five years of experience in Java/J2ee technology. He also has strong experience in Core Java , Apache OFBIZ, JSP, Spring MVC, Struts, Hibernate with JPA, JQuery/Java script,MYSQL, POSTGRESQL and so forth