Skip to main content

Posts

Java Constructor vs method

Functionally difference between constructors and methods is that constructors create and initialize objects that don't exist yet, while methods perform operations on objects that already exist.

Constructors can't be called directly. They are invoked implicitly when the new keyword creates an object.
Methods can be called directly on an object that has already been created with new.

Constructors must be named with the same name as the class name.

Constructors cannot  return anything, even void .

Methods must be declared to return something ( or void).

Constructor compiler provide default constructor where as method compiler does't provide.

Constructor cannot be final since it cant be inherited.

Constructor cannot be abstract since it is used to create and initialize object.

Constructor cannot be static since it is used to create instance of object.

Only public, protected & private modifiers are permitted.
Recent posts

immutable objects in java

In software programming, an immutable object is an object whose state cannot be modified after it is created.

How to make Immutable Object in Java


Make the class final.Make all members final, set them explicitly, in a static block, or in the constructor.Make all members private.Do not expose any setter methods.If the instance fields include references to mutable objects, then don't share references to the mutable objects. For getter methods which needs to return mutable objects, create copies of your internal mutable objects when necessary to avoid returning the originals in your methods.Do not store references to external mutable objects passed to the constructor. Create copies, and store references to the copies. 

Advantage of Immutable Objects

Immutable Objects are ThreadSafe.
Value Objects are generally considered Immutable. In java String and all the Wrapper Classes like Integer, Boolean are immutable.
It enhances security and less bug when the object we are designing is not sup…

Better ways to implement Singleton in Java

Singleton Design pattern restrict creation of only once instance of a Class. That means inside a single JVM only one instance of the Singleton Class will be created.  In java we have broadly two options to implement Singleton.

1)
2) Lazy Creation of the Object Instance: Here the instance is created on first invocation.

Following example demonstrate how to implement Singleton in Java.

Method 1: Early Creation of Object Instance
publicclassSingletonClass{privatestaticfinal SingletonClass INSTANCE =new SingletonClass(); //Private Constructor private SingletonClass(){ //Do nothing}publicstatic SingletonClass getInstance(){ return INSTANCE;}} Here the instance is created ahead even before calling the Class. We need to provide a private constructor otherwise Java Compiler will add a default Constructor.

Method 2: Lazy Creation of Object Instance
public class SingletonClass { privatestaticvolatile SingletonClass INSTANCE =null;private

Java on Mac

Listing all installed Java
/usr/libexec/java_home -V
Matching Java Virtual Machines (5):     1.8.0_45, x86_64:"Java SE 8"/Library/Java/JavaVirtualMachines/jdk1.8.0_45.jdk/Contents/Home     1.8.0_25, x86_64:"Java SE 8"/Library/Java/JavaVirtualMachines/jdk1.8.0_25.jdk/Contents/Home     1.7.0_51, x86_64:"Java SE 7"/Library/Java/JavaVirtualMachines/jdk1.7.0_51.jdk/Contents/Home     1.6.0_65-b14-466.1, x86_64:"Java SE 6"/System/Library/Java/JavaVirtualMachines/1.6.0.jdk/Contents/Home     1.6.0_65-b14-466.1, i386:"Java SE 6"/System/Library/Java/JavaVirtualMachines/1.6.0.jdk/Contents/Home

Selecting a particular version /usr/libexec/java_home -v 1.8

Interpreter Design Pattern

Type: Behavioral Design Pattern
Summary : Interpreter design pattern is a behavioral design pattern. It is used to interpret or evaluate an expression(like sentence, query, mathematical expression etc). 

In this pattern Expression is considered to be composition or Terminal Expression and Compound Expressions. 

Example:  SQL Squery,  Search engine query processing are example for Interpreter design pattern.

Prototype Design Pattern

Type : Creational Design Pattern Summary :  Prototype Design pattern is use full when creating an Object is expensive. Prototype is based on the idea of having a blueprint object for creating other object instances by cloning it.
In java Prototype Design pattern is implemented by using cloning an existing object.

Advantages: If the creation of new object is expensive then the prototype is the way to go to increase the performance.
Participants: Client : It calls the prototype to  Prototype : It Provides the clone interface. Clones: The clones object that are being created



Builder Design Pattern

Type : Creational Design Pattern
Summary :
Builder pattern is a Creational Design Pattern and solves the problem of creating complex objects or objects whose constructor needs many parameters.
Considering a Class whose constructor has a number of parameters, we have to send all of them to instantiate an instance, which could be error prone and complex sometimes.
Also if the constructor has some optional parameters or if we want to have some parameters to have fixed value, we might end up with a number or Constructors for the object.


Advantages: Reduces the number of constructor by using another object.
Increases the readability of the code and less error prone in passing parameters of same type to the constructor.


Disadvantages: Code duplication as Builder Class needs to copy all the fields from the target object.

Example: For our example we will consider a Class BlogObject which represents a Blog and has a number of fields. Some of the fields like, Tag, Summary etc are optional. Wi…