I would like to mention another aspect which hasn't been mentioned by most others, and that's your constructor public Employee(String, Date, String, Designation, double, Date) The more arguments you add to a constructor, the harder it gets to use because the order of parameters isn't clear anymore. When you have multiple parameters of the same type, like in this case two `String`s and two `Date`s, it becomes very easy to mix them up which causes a bug which is hard to spot when reading the code. A good way to handle this issue for immutable objects is to make the constructor private and call it from a Builder class which is a public class declared inside the class it builds (it needs to be inside to be able to call a private constructor). Employee.Builder builder = new Employee.Builder(); builder.setName(name); builder.setDateOfBirth(dateOfJoining); builder.setEmployeeID(id); builder.setDesignation(designation); builder.setSalary(salary); builder.setDateOfJoining(birthdate); Person p = builder.build(); By the way, do you see the bug I have in that code? Would you be able to spot it if I had called the constructor directly? When you have each method of the `Employee.Builder` return `this`, you can also use a very elegant syntax known as "fluent interface": Person p = new Employee.Builder().setName(name) .setDateOfBirth(birthdate) .setEmployeeID(id) .setDesignation(designation) .setSalary(salary) .setDateOfJoining(dateOfJoining) .build();