Re-defining mistake !!!

Ok,yes,it's a mistake.I know it's a mistake.
But their r certain things in life where u knw it's a mistake but u don't really knw it's a mistake bcos the only way to really knw its a mistake is to make the mistake, and look back, and say, "Yep. That was a mistake."

going by this premise

Really,the bigger mistake would be to not make the mistake, bcos then u go ur whole life not really knwng if something is a mistake or not.


And Damm the whole thing... I never made a mistake -:)


Cheers !!!

Difference between Padma Vibhushan, Padma Bhushan and Padma Shri

Padma Vibhushan
The Padma Vibhushan is India's second highest civilian honour. It consists of a medal and a citation and is awarded by the President of India.

It is awarded to recognize exceptional and distinguished service to the nation in any field, including government service. The award was suspended between 1977 and 1980. No award was made between 1992 and 1998 as well.

The award was established by Presidential decree on 2 January 1954. It comes after the Bharat Ratna and before the Padma Bhushan. Padma Vibhushan was originally established as the Pahela Varg (First Class) of a three-class "Padma Vibhushan" awards. However the structure was changed in 1955 and there is no record of the award being presented to any of the recipients in the original structure.


Padma Bhushan
The Padma Bhushan award is an Indian civilian decoration established on January 2, 1954 by the President of India. It stands third in the hierarchy of civilian awards, after the Bharat Ratna and the Padma Vibhushan, but comes before the Padma Sri. It is awarded to recognize distinguished service of a high order to the nation, in any field.


Padma Shri
Padma Shri (also spelt Padma Shree, Padmashree, Padma Sree and Padma Sri) is an award given by the Government of India generally to Indian citizens to recognize their distinguished contribution in various spheres of activity including the Arts, Education, Industry, Literature, Science, Sports, Social Service and public life. (The word "Padma" (Sanskrit) means "Lotus".)

It stands fourth in the hierarchy of civilian awards after the Bharat Ratna, the Padma Vibhushan and the Padma Bhushan. On its obverse, the words "Padma" and "Shri", in Devanagari, appear above and below the lotus flower. The geometrical pattern on either side is in burnished bronze. All embossing is in white gold.



I felt enlighted to learn more about my country's hightest civilian honors. Hope you enjoyed it too !!!



Cheers !!!

Why it is not advisable to declare a constructor in servlet?

Technically you can define constructors in servlet. But, the declared constructor cannot access the ServletConfig object or throw a ServletException so placing a constructor wouldn't add much value and hence we usually don't do it.

Then why is it not customary to declare a constructor in a servlet? Because the init() method is used to perform servlet initialization. In JDK 1.0 (servlet were written in this version), constructors for dynamically loaded Java classes such as servlets cannot accept arguments. Also, Java constructors cannot be declared in interfaces and javax.servlet.Servlet is an interface. Now the classes which implement this interface are GenericServlet and HttpServlet which don't do anything in these constructors [as per the API documentation].

So, javax.servlet.Servlet interface cannot have a constructor that accepts a ServletConfig parameter. To overcome this, init() method is used for initialization instead of declaring a constructor.

This is what I think, please go ahead and pen down on what you think about this and if you differ from my opinion, I assure you that you won't be the first one.



Cheers !!!
Vinay

What happens if you call destroy() from init() in a servlet ?

Well the answer [believe me I was surprised to know this] is :-
destroy() gets executed and the initialization process continues.

Explanation:-In java servlet, destroy() is not supposed to be called by the programmer. But, if it is invoked, it gets executed. The implicit question is, will the servlet get destroyed? No, it will not. destroy() method is not supposed to and will not destroy a java servlet. Don’t get confused by the name. It should have been better, if it was named onDestroy().

The meaning of destroy() in java servlet is, the content gets executed just before when the container decides to destroy the servlet. But if you invoke the destroy() method yourself, the content just gets executed and then the respective process continues. With respective to this question, the destroy() gets executed and then the servlet initialization gets completed.

If you still aren't clear, then please re-visit servlet life cycle once.


Cheers !!!
Vinay

ALL-IN-ONE (Association, Aggregation, Composition, Abstraction, Generalization, Realization, Dependency)

These terms signify the relationships between classes. These are the building blocks of object oriented programming and very basic stuff. But still for some, these terms look like Latin and Greek. Just wanted to refresh these terms and explain in simpler terms.

Association
1) Association is a relationship between two objects. In other words, association defines the multiplicity between objects.
2) Different types of association between objects are:- one-to-one, one-to-many, many-to-one, many-to-many.
3) Example: A Student and a Faculty are having an association.


Aggregation
1) It is a specific case of association.
2) Aggregation is also called a “Has-a” relationship i.e. When an object ‘has-a’ another object, then you have got an aggregation between them.

Composition
1) Composition is a special case of aggregation.
2) When an object contains the other object, if the contained object cannot exist without the existence of container object, then it is called composition.

Difference between aggregation and composition
1) When there is a composition between two objects, the composed object cannot exist without the other object. Composition is more restrictive. This restriction is not there in aggregation.
2) In aggregation, though one object can contain the other object, there is no condition that the composed object must exist. The existence of the composed object is entirely optional.
3) In both aggregation and composition, direction is must. The direction specifies, which object contains the other object.
4) Example: - Let analyze Library, Student and Books.

Relationship between library and student is aggregation because a student can exist without a library and therefore it is aggregation.

Relationship between library and book is composition because A book cannot exist without a library and therefore its a composition.

In terms of coding snippet example of difference between aggregation and composition

Aggregation Example: the object exists outside the other, is created outside, so it is passed as an argument (for example) to the constructor. Ex: People – car. The car is created in a different context and then becomes a person’s property.

****************************************************************************

// WebServer is aggregated of a HttpListener and a RequestProcessor

public class WebServer

{

private HttpListener listener;

private RequestProcessor processor;
public WebServer(HttpListener listener, RequestProcessor processor)

{

this.listener = listener;

this.processor = processor;

}

}

****************************************************************************

Composition Example: the object only exists, or only makes sense inside the other, as a part of the other. Ex: People – heart. You don’t create a heart and then passes it to a person.

$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$

// WebServer is an composition of HttpListener and RequestProcessor & controls their lifecycle

public class WebServer

{

private HttpListener listener;

private RequestProcessor processor;
public WebServer()

{

this.listener = new HttpListener(80);

this.processor = new RequestProcessor(“/www/root”);

}

}

$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$

Here the key difference [wrt code snippet above] to note is that :-

In Aggregation we are passing the already instantiated objects [ HttpListener and RequestProcessor ] from outside the Webserver class so they exist independently of the Webserver class though Webserver class shares “has-a” relationship with them.

In Composition we are instantiating the classes [ HttpListener and RequestProcessor with in the Webserver class so they are dependent on Webserver class. Here also Webserver class shares “has-a” relationship with them.


Abstraction
1) Abstraction is specifying the framework and hiding the implementation level information. Concreteness will be built on top of the abstraction.
2) It gives you a blueprint to follow to while implementing the details. Abstraction reduces the complexity by hiding low level details.
3) Example: A wire frame model of a car.



Generalization
1) Generalization uses a “is-a” relationship from a specialization to the generalization class.
2) Example: (a) Consider there exists a class named Person. A student is a person. A faculty is a person. Therefore here the relationship between student and person, similarly faculty and person is generalization. (b) Lets have specialization class [Triangle and Circle] and generalization class [shape] so the relationship b/w specialization to generalization class is that every Square “is-a” Shape.



Realization
1) Realization is a relationship between the blueprint class and the object containing its respective implementation level details. This object is said to realize the blueprint class.
2) In other words, you can understand this as the relationship between the interface and the implementing class.

Dependency
Change in structure or behavior of a class affects the other related class, then there is a dependency between those two classes.

Please feel free to disagree (if you find anything wroing) on the above explanations and believe me you won't be the first one. Do spare me for any typo's above (if any). Happy-to-learn !!!

Cheers,

Vinay

Factory design pattern [with sample implementation in java]

Definition -- Factory design pattern
Provides an abstraction (usually via an interface) and lets subclass / implementing classes decide which class / method should be instantiated / called, based on the conditions or parameters given.

Intent :-
Factory Method lets a class defer instantiation to subclasses.
To delegate responsibility among different objects and this kind of partitioning is good since it encourages Encapsulation and Delegation.

Discussion :-
Lets leave aside java concepts for a moment and think what a factory in general does? Yes, ask this question to yourself that what any typical factory [say a Toy factory which makes different kind of toys some in shape of aeroplane, some in shape of a racing car] functions?

Now what a factory owner will do to maximize his profit and allow new toys to be build seamlessly is exactly the same what we are going to do in our java classes.

What the toy factory owner will do is that in one chamber of the factory, he will have molten plaster-of-paris (or other material) and then bring it to another chamber where he has kept different toy structures like in the shape of aeroplane / jeep etc and then pour the molten plaster-of-paris into those structures and when it solidifies, he gets the toy of that shape. So the molten plaster-of-paris doesn't know until at the end moment that which structure it would be poured in and what toy would come out but then for sure it would be a toy.

Now lets see how we utilize this concept in java. The molten plaster-of-paris is equivalent to a interface i.e. a standard agreement that it can be converted into any toy provided its poured into a shape/structure.
The structures of aeroplane/jeep are the concrete subclasses which implement the contract with the molten P-o-P. Now what toy would turn out is not known until its poured is similar to getting the objects at runtime.

This we can say that...
Factory Method is to creating objects <==is similar to==> Template to implementing an algorithm/rule [molten P-o-P into structures].
In technical terms, A superclass specifies all standard and generic behavior and then delegates the creation details to subclasses that are supplied by the client.

Why to use Factory design pattern?
We would use a pattern only if its benefits us/our solution in some way or the other. So benefits of Factory pattern are:-

• A family of objects is separated by using shared interface.
• Hide concrete classes from the client.
• The advantage of a Factory Method is that it can return the same instance multiple times, or can return a subclass rather than an object of that exact type.
• The "new" operator is considered harmful. There is a difference between requesting an object and creating one. The "new" operator always creates an object, and fails to encapsulate object creation. A Factory Method enforces that encapsulation, and allows an object to be requested without inextricable coupling to the act of creation.

Where to use a Factory pattern?

• A class cannot anticipate its subclasses, which must be created.
• A sample scenario:- One typical use of the Factory Pattern in an Enterprise JavaBean (EJB) Application: An entity bean is an object representation of persistent data that are maintained in a permanent data store, such as a database. A primary key identifies each instance of an entity bean. Entity beans can be created by creating an object using an object factory Create method. Similarly, Session beans can be created by creating an object using an object factory Create method.

Sample implementation of Factory pattern [in java programming language] :-

• Here, I have used 6 [classes and interfaces] to provide a sample implementation.
• The purpose of each class and interface is explained at the beginning of the source code along with other important points.
• Here you can begin looking at FactoryPatternDemo.java class which has the main() method as a starting point.
  

(1) ************ start of Constants.java ************
/**
* Purpose:- Class to accomodate constants at one place.
*/
package factoryPattern;

/**
* @author Vinay K Mudgil
*
*/
public class Constants {

public static final String CONSOLE_LOG = "consoleWriter";
public static final String FILE_LOG = "fileWriter";

public static final String logFileName = "TestLogFile.log";
public static final String logFileLocation = "/home/vm234069/Desktop/";
}
************ end of Constants.java ************


(2) ************ start of ConsoleLogWriter.java ************
/**
* Purpose:- The usage of this class is to implement the console logging functionality
*/
package factoryPattern;

/**
* @author Vinay K Mudgil
*
*/
public class ConsoleLogWriter implements ILogWriter {

private boolean isDebugModeOn = false;

public void setDebugMode(boolean value) {
this.isDebugModeOn = value;
}

public void printErrorStatement(String errMsg) {
if (isDebugModeOn)
System.out.println("Printing error message on console.");
}

public void printDebugStatement(String debugMsg) {
if (isDebugModeOn)
System.out.println("Printing debug message on console.");
}

}
************ end of ConsoleLogWriter.java ************

(3) ************ start of FactoryPatternDemo.java ************
/**
* Purpose:- To demonstrate factory pattern.
*/
package factoryPattern;

/**
* @author Vinay K Mudgil
*
*/
public class FactoryPatternDemo {

public static void main(String[] args) {

//First lets write to a console.
ConsoleLogWriter clg = (ConsoleLogWriter) LogFactory.getLogWriter(Constants.CONSOLE_LOG);
clg.setDebugMode(true);
clg.printDebugStatement("debug message");
clg.printErrorStatement("error message");

//now lets write to a log file.
FileLogWriter flw = (FileLogWriter) LogFactory.getLogWriter(Constants.FILE_LOG);
flw.setDebugMode(true);
flw.openLogFile();
flw.printDebugStatement("debug message");
flw.printErrorStatement("error message");
flw.closeLogFile();

}

}
************ end of FactoryPatternDemo.java ************


(4) ************ start of FileLogWriter.java************
/**
* Purpose:- The usage of this class is to implement the console logging functionality
*/
package factoryPattern;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

/**
* @author Vinay K Mudgil
*
*/
public class FileLogWriter extends Constants implements ILogWriter{

private boolean isDebugModeOn = false;
private BufferedWriter bw = null;


public void openLogFile() {
try {
bw = new BufferedWriter(new FileWriter(logFileLocation+logFileName));
} catch (IOException ioe) {
ioe.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
}


public void setDebugMode(boolean value) {
this.isDebugModeOn = value;
}


public void printErrorStatement(String errMsg) {
try {
if(bw != null) {
bw.write(errMsg+" -- Printing error message in log file.\n");
bw.flush();
}
} catch (IOException ioe) {
System.out.println("IOException via writing error Message");
} catch (Exception e) {
System.out.println("Exception via writing error Message");
}
}

public void printDebugStatement(String debugMsg) {
try {
if(bw != null) {
bw.write(debugMsg +" -- Printing debug message in log file.\n");
bw.flush();
}
} catch (IOException ioe) {
System.out.println("IOException via writing debug Message");
} catch (Exception e) {
System.out.println("Exception via writing debug Message");
}

}

public void closeLogFile() {

try {
if(bw != null) {
bw.close();
}
} catch (IOException ioe) {
System.out.println("IOException while closing the file.");
}
}

}

************ end of FileLogWriter.java ************


(5) ************ start of ILogWriter.java ************
/**
* Purpose:- The purpose of this interface is to provide an agreement of some basic functionalities which any generic
* LogWriter should provide
*/
package factoryPattern;

/**
* @author Vinay K Mudgil
*
*/
public interface ILogWriter {

//turn on/off the debug mode
public void setDebugMode(boolean value);

//write an error statement
public void printErrorStatement(String errMsg);

//write an debug statement
public void printDebugStatement(String debugMsg);

} //enf of Interface definition
************ end of ILogWriter.java ************


(6) ************ start of LogFactory.java ************
/**
* Purpose:- This is the factory class which actually creates the concrete class type depending on which is required by the client.
*/
package factoryPattern;

/**
* @author Vinay K Mudgil
*
*/
public class LogFactory extends Constants {

// method returning appropriate class object
public static ILogWriter getLogWriter(String writerType) {
if (writerType.equals(Constants.CONSOLE_LOG)) {
return new ConsoleLogWriter();
} else if (writerType.equals(Constants.FILE_LOG)) {
return new FileLogWriter();
}

System.out.println("illegal logging selection...");
return null;
}
}

************ end of LogFactory.java ************

Please feel free to comment on concepts 'n' sample code snippet provided above & spare me for any typo's. Happy to learn !!!

Thanks !!!

kiss - Prototype design pattern

Before I start let me make kiss very clear. Its an acronym for "keep it short & simple". I found this pattern fairly interesting and in fact got into the realm of "cloning" in java due to this, so thought to share my learning and experiences on this design pattern.

What is a prototype design pattern?
In this point we should be exploring the intent of the prototype design pattern, which is :-

• It specifies the kinds of objects to create using a prototypical instance, and create new objects by copying this prototype.

• This pattern co-opt one instance of a class for use as a breeder of all future instances.

• This pattern sees the java "new" operator as cumbersome.

Okayy, the jist is, we create an object of a class once & then clone the object another instance is required.


Why to use prototype design pattern?

We would use a pattern only if its benefits us/our solution in some way or the other. So benifits of prototype pattern are:-

• Whenever object initialization is expensive [of-course to the compiler in terms of time 'n' resources] and you anticipate few variations on the initialization parameters, there this pattern could be used.

• It allows a developer to add / remove attributes at runtime.

• It allows a developer to specify new objects in terms of varying values.

Where to use a prototype pattern?

1. When there are many subclasses that differ only in the kind of objects.
2. A sample scenario:- "There are two class instance(say) that need to be populated with some values, retrieved from the database.The first instance contains values sorted on some key value,while the other is sorted base on some other key(but containing the same data). Now there can be two mechanism for fulfilling the above requirement:- a) Sort the values from the database and then populate in the class,hence the database retrieval is performed 2 times(or n times for n instances). Or b) get the values from the database(one time), populate a single instance, override the clone() method,and then perform cloning."
   

Sample implementation of prototype pattern [in java programming language] :-

• Here I have used 8 [classes and interfaces] to provide a sample implementation.
• The purpose of each class and interface is explained at the beginning of the source code along with other important points.
• Here you can be starting at PrototypeDemo.java class which has the main() method as a starting point.
  

(1) ************ start of Constants.java ************
/**
* Purpose:- To place constants used through-ouot the example for Prototype pattern at one place.
*/

package prototypePattern;

/**
* @author Vinay K Mudgil
*
*/
public class Constants {

public static final String SQUARE = "Square";
public static final String TRIANGLE = "Triangle";
public static final String RECTANGLE = "Rectangle";

public static final int numOfMasterObjects = 10;

}
************ end of Constants.java ************


(2) ************ start of Prototype.java ************
/**
* Purpose:- The purpose of this class is to provide an agreement (thereby abstraction also) so that the class which implement this
* interface have to override the declared methods.
*
* Notes:- (1) By default (implictly) interface members are public, static and final i.e. they are constants and coan't be modified.
* (2) They support the concept of multiple inheritence.
*/

package prototypePattern;

/**
* @author Vinay K Mudgil
*/

public interface Prototype {

//The purpose is to get the name which is to be cloned.
public String getName();

//The purpose is that class implementing this interface should override the clone method.
public Object clone() throws CloneNotSupportedException;
}

************ end of Prototype.java ************


(3) ************ start of PrototypeDemo.java ************
/**
* Purpose:- Class which is used to show the "prototype" pattern in java works :)
* i.e. its a client application which uses a prototype design pattern
*/

package prototypePattern;

/**
* @author Vinay K Mudgil
*
*/
public class PrototypeDemo {

//used to load the
public static void loadMasterObjectsAtBegining() {
ProtoTypeMaster.addPrototype(new Triangle());
ProtoTypeMaster.addPrototype(new Square());
ProtoTypeMaster.addPrototype(new Rectangle());
}

public static void main(String[] args) throws CloneNotSupportedException {
System.out.println("starting execution now.....");
Object [] clonedObjectArray = new Object[args.length];
int count=0;

//intialize
PrototypeDemo.loadMasterObjectsAtBegining();

//For each command-line argument, lets see if we can create a clone.
for(int i=0;i if( (ProtoTypeMaster.findAndClone(args[i]) ) != null) {
clonedObjectArray[count] = ProtoTypeMaster.findAndClone(args[i]);
count++;
}

}

//now, just for sample, lets execute draw method to show that we created cloned objects.
for(int i=0; i if (clonedObjectArray[i] != null)
((UtilityFunctions) clonedObjectArray[i] ).draw();
}

} //end of main method

}//end of class
************ end of ************


(4) ************ start of ProtoTypeMaster.java************
/**
* Purpose:- To hold objects of class which are to be cloned.
*/

package prototypePattern;

/**
* @author Vinay K Mudgil
*
*/

public class ProtoTypeMaster extends Constants{

private static Prototype [] masterObjectHolder = new Prototype [Constants.numOfMasterObjects];

//variable which holds the current count of
private static int currentCount = 0;

/*
* Purpose:- Add relevant object to the masterObjectHolder
*/
public static void addPrototype(Prototype pObj) {

if(currentCount < Constants.numOfMasterObjects)
masterObjectHolder[currentCount++] = pObj;
else
System.out.println("This Addition would exceedes max. number of allowed objects which can be Prototyped and hence rejecting this addition");
} //end of addPrototype() method


/*
* Purpose:- To search for the relevant class to be cloned and then clone that class and return the cloned instance.
*/
public static Object findAndClone (String classNameToBeCloned) throws CloneNotSupportedException {

//first search in the masterObjectHolder that which relevant class is to be cloned
for(int i=0; i < currentCount; i++) {

if ( masterObjectHolder[i].getName().equals(classNameToBeCloned) ) {
//now that our search is successful, lets clone the object and return it.
return masterObjectHolder[i].clone();
}
}

System.out.println("class name which you supplied at \"runtime\" couldn't be found in the masterObjectHolder and hence can't be cloned");
return null;
}


} //end of class
************ end of ProtoTypeMaster.java ************


(5) ************ start of Rectangle.java ************
/**
* Purpose:- To provide a class (for testing) which can be cloned.
*/
package prototypePattern;

/**
* @author Vinay K Mudgil
*
*/
public class Rectangle extends Constants implements Prototype, UtilityFunctions, Cloneable {

public String getName() {
return Constants.RECTANGLE;
}

public void draw() {
System.out.println("Drawing a Rectangle");
}

public Object clone() throws CloneNotSupportedException {
return (Rectangle) super.clone();
}

}//end-of-class
************ end of Rectangle.java ************


(6) ************ start of Square.java ************
/**
* Purpose:- To provide a class (for testing) which can be cloned.
*/
package prototypePattern;

/**
* @author Vinay K Mudgil
*
*/
public class Square extends Constants implements Prototype, UtilityFunctions, Cloneable {
public String getName() {
return Constants.SQUARE;
}

public void draw() {
System.out.println("Drawing a Square");
}

public Object clone() throws CloneNotSupportedException {
return (Square) super.clone();
}

}//end-of-class
************ end of Square.java ************


(7) ************ start of Triangle.java************
/**
* Purpose:- To provide a class (for testing) which can be cloned.
*/

package prototypePattern;

/**
* @author Vinay K Mudgil
*
*/

public class Triangle extends Constants implements Prototype, UtilityFunctions, Cloneable {
public String getName() {
return Constants.TRIANGLE;
}

public void draw() {
System.out.println("Drawing a Triangle");
}

public Object clone() throws CloneNotSupportedException {
return (Triangle) super.clone();
}

}//end-of-class
************ end of Triangle.java ************


(8) ************ start of UtilityFunctions.java ************
/**
* Purpose:- This interface is created to give you an idea that in real world scenerio's this interface is overridden by class
* to provide their own implementation of a methods
*/

package prototypePattern;

/**
* @author Vinay K Mudgil
*
*/

public interface UtilityFunctions {

//sample method which every first concrete sub-class would provide an implementation for.
public void draw();
}
************ end of UtilityFunctions.java ************


Please feel free to comment on concepts & sample code snippet provided above. Happy to learn from you.

Thanks !!!