return fileName;
}
public void logMsg(Priority p, String message) {
try {
GregorianCalendar gc = new GregorianCalendar();
String fileName = getFileName(gc); FileOutputStream fos = new FileOutputStream(fileName, true); PrintStream ps = new PrintStream(fos); SimpleDateFormat dateFormat2 = new SimpleDateFormat("EEE, MMM d, yyyy 'at' hh:mm:ss a"); ps.println("<"+dateFormat2.format (gc.getTime())+">["+message+"]"); ps.close();
}
catch (IOException ie) { ie.printStackTrace();
}}
public static void initialize() {
logger = new Logger();
}
// singleton - pattern
private static Logger logger;
public static Logger getLogger() { return logger;
}}

Example:

final class Logger {
//implementation of a static class of a
Singleton pattern
static public void logMessage(String s) {
System.out.println(s);
}}
public class StaticLogger {
public static void main(String args[]) {
Logger.logMessage("This is SINGLETON");
}}

The advantage of this static approach is that it’s easier to use. The disadvantage of course is that if in future you do not want the class to be static anymore, you will have to do a lot of recoding.

Builder Pattern:

This design pattern allows the client to construct a complex object based on its type and content. One can achieve the way of constructing the objects by using the factory pattern. This is similar to the abstract factory pattern as both returns a group of related objects. The only difference between these two patterns is that Builder pattern makes a complex object step by step on the basis of data passed to it.

Benefits: These types of patterns provide greater control over construction process, separation between the construction and representation, and support to change the internal representation of objects.

Usage: Builder is useful in those conditions where you need to assemble several different kinds of complex objects at runtime. Once it is created it isolates the building process of object, from the object itself. Different objects may be constructed by using similar methods but once the