The main purpose of constructors is to set the initial state of an object when the object is created by using the new operator. A constructor has the following general syntax: Constructor declarations are very much like method declarations. However, the following restrictions on constructors should be noted:
Class names and method names exist in different namespaces . Thus, there are no name conflicts in Example 4.5, where a method declared at (2) has the same name as the constructor declared at (1). However, using such naming schemes is strongly discouraged. Example 4.5 Namespacespublic class Name { Name() { // (1) System.out.println("Constructor"); } void Name() { // (2) System.out.println("Method"); } public static void main(String[] args) { new Name().Name(); // (3) Constructor call followed by method call. } } Output from the program: Constructor Method Default ConstructorA default constructor is a constructor without any parameters. In other words, it has the following signature: If a class does not specify any constructors, then an implicit default constructor is supplied for the class. The implicit default constructor is equivalent to the following implementation: The only action taken by the implicit default constructor is to call the superclass constructor. This ensures that the inherited state of the object is initialized properly (see Section 6.3, p. 243). In addition, all instance variables in the object are set to the default value of their type. In the following code, the class Light does not specify any constructors. class Light { // Fields int noOfWatts; // wattage boolean indicator; // on or off String location; // placement // No constructors //... } class Greenhouse { // ... Light oneLight = new Light(); // (1) Call of implicit default constructor. } In the previous code, the following implicit default constructor is employed when a Light object is created at (1): Light() { super(); } Creating an object using the new operator with the implicit default constructor, as at (1), will initialize the fields of the object to their default values (i.e., the fields noOfWatts , indicator , and location in a Light object will be initialized to , false , and null , respectively). A class can choose to provide an implementation of the default constructor. In the following example, the class Light provides an explicit default constructor at (1). Note that it has the same name as the class, and that it does not take any parameters. class Light { // ... // Explicit Default Constructor Light() { // (1) noOfWatts = 50; indicator = true; location = "X"; } //... } class Greenhouse { // ... Light extraLight = new Light(); // (2) Call of explicit default constructor. } The explicit default constructor ensures that any object created with the expression new Light() , as at (2), will have its fields noOfWatts , indicator and location initialized to 50 , true and "X" , respectively. If a class defines any explicit constructors, it can no longer rely on the implicit default constructor to set the state of the objects. If such a class requires a default constructor, its implementation must be provided. In the example below, class Light only provides a non-default constructor at (1). It is called at (2) when an object of class Light is created with the new operator. Any attempt to call the default constructor will be flagged as a compile time error as shown at (3). class Light { // ... // Only non-default Constructor Light(int noOfWatts, boolean indicator, String location) { // (1) this.noOfWatts = noOfWatts; this.indicator = indicator; this.location = location; } //... } class Greenhouse { // ... Light moreLight = new Light(100, true, "Greenhouse"); // (2) OK. // Light firstLight = new Light(); // (3) Compile time error. } Overloaded ConstructorsLike methods , constructors can also be overloaded. Since the constructors in a class all have the same name as the class, their signatures are differentiated by their parameter lists. In the following example, the class Light now provides both an explicit implementation of the default constructor at (1) and a non-default constructor at (2). The constructors are overloaded, as is evident by their signatures. The non-default constructor is called when an object of class Light is created at (3), and the default constructor is likewise called at (4). Overloading of constructors allows appropriate initialization of objects on creation, depending on the constructor invoked (see also chaining of constructors in Section 6.3, p. 243.) class Light { // ... // Explicit Default Constructor Light() { // (1) noOfWatts = 50; indicator = true; location = "X"; } // Non-default Constructor Light(int noOfWatts, boolean indicator, String location) { // (2) this.noOfWatts = noOfWatts; this.indicator = indicator; this.location = location; } //... } class Greenhouse { // ... Light moreLight = new Light(100, true, "Greenhouse"); // (3) OK. Light firstLight = new Light(); // (4) OK. } |