Design patterns in java (Part1)
Java offers solutions for software design. These design patterns provides great solutions in efficient manner. These are easy to maintain. Java’s design patterns are listed below.
- 1. Singleton pattern
- 2. Factory pattern
- 3. Observer pattern
- 4. Decorator pattern
- 5. Strategy pattern
Each and every pattern is detailed explained as follows.
1.Singleton pattern:
Single
instance is created with the global scope. The instance can be visible for
entire project.
Steps:
- · First,create a singleton class. Develop a singleton instance code as private,static and final type.
- · Just return the instance from a public member function getInsta().
- · Secondly, a public class SingletonEg is written with main function.
- · s1,s2 are the two instances developed from Singleton class.
- · Check whether both are true.
- · Yes, both are equal because these two are same singleton objects.
class Singleton {
private static
final Singleton insta = new Singleton();
private
Singleton() {}
public static
Singleton getInsta() {
return insta;
}
}
public class SingletonEg {
public static void
main(String[] args) {
Singleton s1 =
Singleton.getInsta();
Singleton s2 =
Singleton.getInsta();
if (s1 == s2)
{
System.out.println("Both singleton instances are same");
}
}
}
The output is….
C:\raji\blog>javac SingletonEg.java
C:\raji\blog>java SingletonEg.java
Both singleton instances are same
Next is factory pattern.
2.Factory pattern:
Creating
an interface with objects and function. Let it can be overridden by sub class.
Steps:
- · Write an interface with void function.
- · Add two concrete classes implementing the same interface.
- · Develop a Factory to generate object of concrete class based on given information
- · Let the fruit class object uses the fruitfactory function.
- · Interface: fruit
- · Concrete classes: Apple and Orange.
- · Factory class: fruitFactory
- · Main class :FactoryPatternEg
Program:
interface fruit {
void color();
}
class Apple implements fruit {
@Override
public void
color() {
System.out.println("Apple is red colour.");
}
}
class Orange implements fruit {
@Override
public void
color() {
System.out.println("Orange is orange colour.");
}
}
public fruit
getFruit(String fruitType) {
if (fruitType
== null) {
return
null;
}
if
(fruitType.equalsIgnoreCase("APPLE")) {
return new
Apple();
} else if
(fruitType.equalsIgnoreCase("ORANGE")) {
return new
Orange();
}
return null;
}
}
public static void
main(String[] args) {
fruitFactory
ff1 = new fruitFactory();
// Get an
object of apple and call its color method
fruit f1 =
ff1.getFruit("APPLE");
f1.color();
// Get an
object of Orange and call its color method
fruit f2 =
ff1.getFruit("ORANGE");
f2.color();
}
}
Compile and run the program in command prompt. you will get the output.
C:\raji\blog>javac FactoryPatternEg.java
Apple is red colour.
Orange is orange colour.
These are the first two design patterns in java. Next blog post shows you the remaining Design patterns.
Comments
Post a Comment