Java uses constructors to create new objects from class blueprints. These routines are key for ensuring proper state upon object instantiation and offer developers lots of options. Whether you’re overloading, chaining, or overriding\u2014constructors in Java can make programming much more efficient.<\/p>\n
Before diving into Java’s implementation of constructors it’s important to note that Java does not require classes to define constructors explicitly<\/strong>. If a constructor isn’t explicitly defined, the compiler will automatically create a no-argument default constructor for the class.<\/p>\n Constructors look a lot like methods. They have names, access modifiers, and can even accept arguments. The notable difference between a Java constructor and class method is that the constructor has the same name as the Class and no specified return type. Here are the main characteristics of the signature of a Java constructor:<\/p>\n When these characteristics are satisfied, Java uses a constructor method to instantiate a new class object with the desired state. When there is an error in these, Java will generate a compile-time exception. However, Java doesn’t require a constructor to be declared explicitly. In such cases, Java has a default constructor routine.<\/p>\n When a constructor isn’t explicitly defined, Java will automatically generate a constructor based on an object’s superclass. In many cases, the superclass is the default Object class.<\/p>\n Per the Java Tutorial’s Documentation<\/a>:<\/p>\n The compiler automatically provides a no-argument, default constructor for any class without constructors. This default constructor will call the no-argument constructor of the superclass. In this situation, the compiler will complain if the superclass doesn’t have a no-argument constructor so you must verify that it does. If your class has no explicit superclass, then it has an implicit superclass of\u00a0<\/em>Object, which\u00a0does\u00a0have a no-argument constructor.<\/em><\/p>\n This means, even if an object is expressing a complex series state of inheritance, the Java compiler will continue looking up the hierarchical tree until it finds a relative with a default no-argument constructor. Worst case scenario: it makes it all the way up to the Java In the example code below, there is no constructor explicitly defined for the Person object class.<\/p>\n This signals Java to use the default constructor from the Person class’s superclass which, in this case, is the Java Object class. Essentially, the code above is the same as the following:<\/p>\n This code is redundant and considered bad-practice. In this case, no functionality is being gained through explicitly calling the superclass’s default constructor. After all, it gets called if there is no explicit constructor. In the next example, the procedure for defining data member values\u00a0and<\/em> using the superclass constructor method is illustrated:<\/p>\n Note<\/strong>: The call to the superclass must be made\u00a0before<\/em> setting values of the data members Java constructors can be implemented in many ways depending on use-case. The following constructor in Java example has no frills and simply ensures the example Java provides access to modifiers to enforce object security. These can be specified using reserved keywords such as Java Constructors<\/h2>\n
\n
Java’s Default Constructor<\/h2>\n
Object<\/code> model.<\/p>\nDefault Constructor Example<\/h2>\n
public class Person{\r\n\r\n \/\/ Data members\r\n String name;\r\n int age;\r\n}<\/pre>\npublic class Person{\r\n\r\n \/\/ Data members\r\n String name;\r\n int age;\r\n \r\n \/\/ Constructor\r\n Person(){\r\n super();\r\n }\r\n}<\/pre>\npublic class Person{\r\n\r\n \/\/ Data members\r\n String name;\r\n int age;\r\n\r\n \/\/ Constructor\r\n Person(){\r\n \r\n \/\/ Call parent constructor\r\n super();\r\n \r\n \/\/ Define data member values\r\n this.name = \"John Doe\";\r\n this.age = 35;\r\n }\r\n}<\/pre>\nname<\/code> and age<\/code> or a compile-time exception will be thrown.<\/p>\nExplicit Constructor Example<\/h2>\n
Person<\/code> object is instantiated with an application-supplied age<\/code> and name<\/code> field.<\/p>\npublic class Person{\r\n \r\n \/\/ Data members\r\n String name;\r\n int age;\r\n \r\n \/\/ Constructor\r\n Person (String name, int age){\r\n this.name = name;\r\n this.age = age;\r\n } \r\n}<\/pre>\nDefault Access Modifiers<\/h2>\n
private<\/code>, public<\/code> and protected<\/code>. In the above examples, the Person<\/code> class is always declared as being public. However, no access-control is explicitly declared for Person<\/code>‘s constructor (when defined). In such cases, Java falls back to the default modifier which is package-private (R<\/a>).<\/p>\nReview<\/h2>\n