A constructor is a named block of code that is used to initialize an object of a class immediately after the object is created. The structure of a constructor looks similar to a method. However, the similarity between the two stops right there, in their looks. They are two different constructs and they are used for different purposes.

The general syntax for a constructor declaration is as follows:

The declaration of a constructor starts with modifiers. A constructor can have its access modifier as public, private, protected, or package-level (no modifier). The constructor name is the same as the simple name of the class. The constructor name is followed by a pair of opening and closing parentheses, which may include parameters. Optionally, the closing parenthesis may be followed by a throws clause, which in turn is followed by a comma-separated list of exceptions. I discuss the use of the keyword throws in the chapter on exception handling. The body of the constructor, where you place your code, is enclosed in braces.

If you compare the syntax to declare a method with the syntax to declare a constructor, you will find that they are almost the same. It is suggested to keep the method declaration in mind when learning about constructor declaration because most of the characteristics are similar.

The following code shows an example of declaring a constructor for a class Test. Figure 9-1 shows the anatomy of the constructor.

Unlike a method, a constructor does not have a return type. You cannot even specify void as a return type for a constructor. Consider the following declaration of a class Test2:

Does the class Test2 declare a constructor? The answer is no. The class Test2 does not declare a constructor. Rather, what you may be looking at is a method declaration, which has the same name as the simple name of the class. It is a method declaration because it specifies a return type of void. Note that a method name could also be the same as the class name, as is the case in this example.

Just the name itself does not make a method or constructor. If the name of a construct is the same as the simple name of the class, it could be a method or a constructor. If it specifies a return type, it is a method. If it does not specify a return type, it is a constructor.

When do you use a constructor? You use a constructor with the new operator to initialize an instance (or an object) of a class just after the new instance is created. Sometimes the phrases “create” and “initialize” are used interchangeably in the context of a constructor. However, you need to be clear about the difference in creating and initializing an object. The new operator creates an object and a constructor initializes that object.

The following statement uses a constructor of the Test class to initialize an object of the Test class:

Figure 9-2 shows the anatomy of this statement . The new operator is followed by the call to the constructor. The new operator, along with the constructor call, for example "new Test()", is called an instance (or object) creation expression. An instance creation expression creates an object in memory, executes the code in the body of the specified constructor, and finally, returns the reference of the new object.

I have covered enough theories for declaring a constructor. It is time to see a constructor in action. Listing 9-1 has the code for a Cat class.

The Cat class declares a constructor. Inside the constructor’s body, it prints a message "Meow...". Listing 9-2 contains the code for a CatTest class , which creates two Cat objects in its main() method. Note that you always use an object creation expression to create a new object of the Cat class. It is up to you to store the reference of the new object in a reference variable. The first Cat object is created and its reference is not stored. The second Cat object is created and its reference is stored in a reference variable c.

A class can have more than one constructor. If a class has multiple constructors, they are called overloaded constructors . Since the name of the constructor must be the same as the simple name of the class, there is a need to differentiate one constructor from another. The rules for overloaded constructors are the same as for overloaded methods. If a class has multiple constructors, all of them must differ from the others in the number, order, or type of parameters. Listing 9-3 contains the code for a Dog class, which declares two constructors. One constructor accepts no parameters and another accepts a String parameter .

If a class declares multiple constructors , you can use any of them to create an object of that class. For example, the following two statements create two objects of the Dog class:

The first statement uses the constructor with no parameters and the second one uses the constructor with a String parameter. If you use a constructor with parameters to create an object, the actual parameter’s order, type, and number must match the formal parameter’s order, type, and number. Listing 9-4 has the complete code that creates two Dog objects using different constructors.

The output of running the DogTest class indicates that different constructors are called when two Dog objects are created in the main() method.

A constructor is called once per object creation expression. You can execute the code for one constructor only once in the process of an object creation. If the code for a constructor is executed N times, it means N number of objects of that class will be created and you must use N number of object creation expressions to do that. However, when an object creation expression calls a constructor, the called constructor may call another constructor from its body. I cover this scenario where one constructor calls another later in this section.

So far, you have been writing trivial code in constructors. What kind of code should you write in a constructor? The purpose of a constructor is to initialize the instance variables of the newly created object. Inside a constructor, you should restrict yourself only to write code that initializes instance variables of the object. An object is not fully created when a constructor is called. The object is still in the process of creation. If you write some processing logic in a constructor assuming that a full blown object exists in memory, sometimes you may get unexpected results. Let’s create another class to represent a dog object. You will call this class SmartDog, as shown in Listing 9-5.

The SmartDog class looks a little bigger. However, its logic is very simple. The following are the main points in the SmartDog class that you need to understand:

Listing 9-6 has the code for a SmartDogTest class that demonstrates how the two constructors initialize the instance variables.

A constructor may call another constructor of the same class. Let’s consider the following Test class. It declares two constructors; one accepts no parameters and one accepts an int parameter.

Suppose you want to call the constructor with an int parameter from the constructor with no parameter. Your first attempt, which is wrong, would be as follows:

The previous code does not compile. Java has a special way to call a constructor from another constructor. You must use the keyword this, as if it is the name of the constructor, to call a constructor from another constructor. The following code calls the constructor with an int parameter from the constructor with no parameter using the statement, "this(103);". This is another use of the keyword this.

There are two rules about calling a constructor from another constructor. The rules ensure that one constructor is executed only once during the process of an object creation of a class. These rules are as follows:

If a constructor calls another constructor, it must be the first executable statement in the constructor’s body. This makes it easy for the compiler to check that a constructor has been called and it has been called only once. For example, the following code will generate a compile-time error because a call to the constructor with int parameter this(k) is the second statement inside the constructor’s body, not the first statement.

A constructor cannot call itself because it will result in a recursive call. In the following code for the Test class , both constructors attempt to call themselves:

An attempt to compile this code will result in the following error. One error message is generated for each attempt to call the constructor itself.

Typically, you create overloaded constructors for a class when you have many ways to initialize an object of the class. Let’s consider the SmartDog class shown in Listing 9-5. Two constructors give you two ways to initialize a new SmartDog object. The first one initializes the name and the price with default values. The second constructor lets you initialize name and price with the value supplied by the caller. Sometimes you may perform some logic to initialize the object inside a constructor. Letting you call another constructor from a constructor allows you to write such logic only once. You can use this feature for your SmartDog class , as shown:

Note that you changed the code only inside the constructor that accepts no parameters. Instead of setting the default values for name and price in the first constructor, you called the second constructor with the default values as parameters from the first one.

A constructor cannot have a return type in its declaration. It means a constructor cannot return any value. Recall that a return statement is of two types: one with a return expression and one without a return expression. The return statement without a return expression simply returns the control to the caller without returning any value. You can use a return statement without a return expression inside a constructor body. When a return statement in a constructor is executed, the control returns to the caller, ignoring the rest of the constructor’s code.

The following code shows an example of using a return statement in a constructor. If the parameter x is a negative number, the constructor simply executes a return statement to end the call to the constructor. Otherwise, it performs some logic.

Access level for a constructor determines the part of the program that can use that constructor in an object creation expression to create an object of that class. Similar to fields and methods, you can specify one of the four access levels for a constructor:

The following code declares four constructors for the Test class . A comment for each constructor explains its access level.

The effect of these access levels is the same as their effect on a method. A constructor with a public access level can be used in any part of the application provided the class itself is accessible. A constructor with private access level can be used only inside the same class in which it is declared. A constructor with protected access level can be used in any part of the program in the same package in which its class is declared and inside any descendant class in any package. A constructor with package-level access can be used inside the same package in which its class is declared.

Let’s discuss the different combinations of access levels for a class and its constructor, and its effects in a program. Consider the following code that declares a class T1 with public access level. It also has a constructor, which also has a public access level:

Because the class T1 has a public access level , you can declare a reference variable of type T1 anywhere in the same module. If this code is in a different module, assume that the module containing the class exports the class' package and the module having this code reads the first module:

Because the constructor for the class T1 has a public access level, you can use it in an object creation expression in any package.

You can combine the previous two statements into one in the code in any package.

Let’s consider the following code for the class T2, which has a public access level and has a constructor with a private access level:

Because class T2 has a public access level, you can use its name to declare a reference variable in any package in the same module. If the package is in a different module, assume that the module can read the package that contains the T2 class. The constructor for class T2 has a private access level. The implication of having a private constructor is that you cannot create an object of the T2 class outside the T2 class. Recall that a private method, field, or a constructor cannot be used outside the class in which it is declared. Therefore, the following code will not compile unless it appears inside the T2 class:

What is the use of the T2 class if you cannot create its object outside of the T2 class? Let’s consider the possible situations where you can declare a constructor private , and still create and use objects of the class.

A constructor is used to create an object of a class . You may want to restrict the number of objects of a class. The only way you can restrict the number of objects of a class is by having full control over its constructors. If you declare all constructors of a class to have the private access level, you have full control over how the objects of that class will be created. Typically, you include one or more public static methods in that class, which create and/or return an object of that class. If you design a class so that only one object of the class may exist, it is called a singleton pattern . The following code is a version of the T2 class that is based on the singleton pattern.

The T2 class declares a private static reference variable called instance , which holds the reference of an object of the T2 class. Note that the T2 class uses its own private constructor to create an object. Its public static getInstance() method returns the lone object of the class. More than one object of the T2 class cannot exist.

You can use the T2.getInstance() method to get the reference of an object of the T2 class. Internally, the T2 class does not create a new object every time you call the T2.getInstance() method. Rather, it returns the same object reference for all calls to this method.

Sometimes you want a class to have only static members. It may not make sense to create an object of such a class. For example, the java.lang.Math class declares its constructor private. The Math class contains static variables and static methods to perform numeric operations. It does not make sense to create an object of the Math class.

You can also declare all constructors of a class private to prevent inheritance. Inheritance lets you define a class by extending the definition of another class. If you do not want anyone else to extend your class, one way to achieve this is to declare all constructors of your class private. Another way to prevent your class from being extended is to declare it final. I discuss inheritance in detail in Chapter 20.

A constructor with protected access level can be used anywhere in the same package or inside a descendant class in any package. The class T3 is in the com.jdojo.cls.p1 package. You can write the following statement anywhere in com.jdojo.cls.p1 package, which creates an object of the T3 class:

I cover inheritance in detail later. However, to complete the discussion of a protected constructor, you will use inheritance in the following example. Things about inheritance will be clearer when I discuss it in Chapter 20. You inherit (or extend) a class using the keyword extends. The following code creates a T3Child class by inheriting it from the T3 class:

The T3 class is called the parent class of the T3Child class. An object of a child class cannot be created until the object of its parent class is created. Note the use of the super() statement inside T3Child() constructor’s body. The statement super() calls the protected constructor of the T3 class. The super keyword is used to call the parent class' constructor as you use the keyword this to call another constructor of the same class. You cannot call the protected constructor of T3 directly as this is outside the com.jdojo.cls.p1 package:

You can use T4’s constructor to create its object anywhere in the com.jdojo.cls.p1 package. Sometimes you need a class that works as a helper class for other classes in a package. Objects of these classes need to be created only within the package. You can specify package-level access for constructors of such helper classes.

The primary goal of declaring a class is to create an object of its type. You need a constructor to create an object of a class. The necessity to have a constructor for a class is so obvious that the Java compiler adds a constructor to your class if you do not declare one. The constructor that is added by the compiler is called the default constructor. The default constructor does not have any parameters. Sometimes the default constructor is also called a no-args constructor . The access level of the default constructor is the same as the access level of the class.

The classes that you have been working with are called top-level classes. You can also declare a class within another class, which is called an inner class . A top-level class can have public or package-level access. However, an inner class can have public, private, protected, or package-level access. The Java compiler adds a default constructor for a top-level class as well as for a nested class . A default constructor for a top-level class can have either public or package-level access, depending on the access level of the class. However, a default constructor for an inner class can have access level of public, private, protected or package-level, depending on its class access level.

Table 9-1 shows a few examples of classes and the compiler adding a default constructor to them. When the compiler adds a default constructor, it also adds a statement called super() to call the no-args constructor of the parent class. Sometimes the call to the parent’s no-args constructor inside the default constructor may cause your class not to compile. Refer to Chapter 20 for a complete discussion on this topic.

Constructors are used in the context of the creating a new object; hence, they are considered part of the object context, not the class context. You cannot declare a constructor static. The keyword this, which is a reference to the current object, is available inside the body of constructors, as it is available inside the body of all instance methods.

You have seen that a constructor is used to initialize an instance of a class. An instance initialization block , also called instance initializer, is also used to initialize objects of a class. Why does Java provide two constructs to perform the same thing?

Not all classes in Java can have a constructor. Are you surprised to learn that not all classes can have constructors? I did not mention this fact during the discussion on constructors. Briefly, I mentioned inner classes, which are different from top-level classes. I discuss one more type of class in volume II of this three-book series called an anonymous class . As the name suggests, an anonymous class does not have a name. Recall that a constructor is a named block of code whose name is the same as the simple name of the class. Because an anonymous class cannot have a name, it cannot have a constructor either. How will you initialize an object of an anonymous class? You can use an instance initializer to initialize an object of an anonymous class. The use of an instance initializer to initialize an object is not limited only to anonymous classes. Any type of class can use it to initialize its objects.

An instance initializer is simply a block of code inside the body of a class, but outside any methods or constructors. Recall that a block of code is a sequence of legal Java statements enclosed within braces. An instance initializer does not have a name. Its code is simply placed inside an opening brace and a closing brace. The following snippet of code shows how to declare an instance initializer for a Test class. Note that an instance initializer is executed in instance context and the keyword this is available inside the instance initializer.

You can have multiple instance initializers for a class. All of them are executed automatically in textual order for every object you create. Code for all instance initializers is executed before any constructors. Listing 9-7 demonstrates the sequence in which the constructor and instance initializers are executed.

A static initialization block is also known as a static initializer. It is similar to an instance initialization block. It is used to initialize a class. In other words, you can initialize class variables inside a static initializer block. An instance initializer is executed once per object, whereas a static initializer is executed only once for a class when the class definition is loaded into JVM. To differentiate it from an instance initializer, you need to use the static keyword at the beginning of its declaration. You can have multiple static initializers in a class. All static initializers are executed in textual order in which they appear and are executed before any instance initializers. Listing 9-8 demonstrates when a static initializer is executed.

The output may be confusing at first. It shows that the static initializer has executed even before the first message is displayed in the main() method . You get the output when you run the StaticInitializer class using the following command:

The java command must load the definition of the StaticInitializer class before it can execute its main() method. When the definition of the StaticInitializer class is loaded into memory, at that time the class is initialized and its static initializer is executed. This is the reason that you see the message from the static initializer before you see the message from the main() method. Note that instance initializer is called twice because you create two objects of the StaticInitializer class.

The final keyword is used in many contexts in a Java. It takes on different meanings in different contexts. However, as its name suggests, its primary meaning is the same in all contexts. Its primary meaning is as follows:

The construct with which the final keyword is associated does not allow modifying or replacing the original value or definition of the construct.

If you remember the primary meaning of the final keyword, it will help you understand its specialized meaning in a specific context. The final keyword can be used in the following three contexts:

In this section, I discuss the use of the final keyword only in the context of a variable declaration . Chapter 20 discusses its use in the context of class and method declarations in detail. In this section, I briefly describe its meaning in all three contexts.

If a variable is declared final, it can be assigned a value only once. That is, the value of a final variable cannot be modified once it has been set. If a class is declared final, it cannot be extended (or subclassed). If a method is declared final, it cannot be redefined (overridden or hidden) in the subclasses of the class that contains the method.

Let’s discuss the use of the final keyword in a variable declaration. In this discussion, a variable declaration means the declaration of a local variable, a formal parameter of a method/constructor, an instance variable, and a class variable. To declare a variable as final, you need to use the final keyword in the variable’s declaration. The following snippet of code declares four final variables: YES, NO, MSG, and act:

You can set the value of a final variable only once. Attempting to set the value of a final variable the second time will generate a compile-time error.

There are two ways to initialize a final variable:

How long you can defer the initialization of a final variable depends on the variable type. However, you must initialize the final variable before it is read the first time.

If you do not initialize a final variable at the time of its declaration, such a variable is known as a blank final variable . The following is an example of declaring a blank final variable.

Abstraction and polymorphism are at the heart of object-oriented programming . Defining a variable is an example of abstraction where the variable hides the actual values and the location where the values are stored. Defining a method hides the details of its implementation logic, which is another form of abstraction. Defining parameters for a method is part of polymorphism that allows the method to work on different types of values or objects.

Java has a feature called generics that allows for writing true polymorphic code in Java. Using generics, you can write code without knowing the type of the objects your code operates on. It lets you create generic classes, constructors, and methods.

A generic class is defined using formal type parameters. Formal type parameters are a list of comma-separated variable names placed in angle-brackets (<>) after the class name in the class declaration. The following snippet of code declares a generic class Wrapper that takes one formal type parameter:

The parameter has been given a name T. What is T at this point? The answer is that you do not know. All you know at this point is that T is a type variable, which could be any reference type in Java, such as String, Integer, Double, Human, Account, etc. The formal type parameter value is specified when the Wrapper class will be used. The classes that take formal type parameters are also known as parameterized classes .

You can declare a variable of the Wrapper<T> class by specifying the String type as the value for its formal type parameter as shown here. Here, String is the actual type parameter.

When a generic class is used without specifying the actual type parameters, it is known as raw type. The previous declaration used the Wrapper<T> class as a raw type, as it did not specify the value for T.

A class may take more than one formal type parameter. The following snippet of code declares a Mapper class that takes two formal parameters named T and R:

Here, the actual type parameters are String and Integer.

It is customary, not a requirement , to give one-character names to the formal type parameters, for example, T, R, U, V, etc. Typically, T stands for “Type”, R for “Return,” etc. One-character names make the code more readable. However, nothing stops you from declaring a generic class as follows, which has four formal type parameters named MyType, YourType, Hello, and WhoCares.

Java will compile the Fun class, but readers of your code will complain for sure! The formal type parameters are available inside the class body to be used as types. Listing 9-9 declares a generic class Wrapper<T>.

The Wrapper<T> class uses the formal type parameter to declare instance variable obj to declare a formal parameter for its constructor and set() method, and as a return type for the get() method.

You can create an object of the generic type by specifying the actual type parameter for the constructor as follows:

Once you have declared a variable of the generic class , you can think of the formal type parameter as the specified actual type parameter for all practical purposes. Now, you can think that, for w1, the get() method of the Wrapper<T> class returns a String.

The program in Listing 9-10 shows how to use the generic Wrapper<T> class.

This is just the tip of the iceberg when it comes to what generics offer in Java. To understand generics completely, you must cover other topics, such as inheritance, first. Generics are covered fully in a separate chapter in the second volume of this three-book series.

A constructor is a named block of code that is used to initialize an object of a class immediately after the object is created. The structure of a constructor looks similar to a method. However, they are two different constructs and they are used for different purposes. The name of a constructor is the same as the simple name of the class. Like methods, constructors may accept parameters. Unlike methods, constructors cannot specify a return type. A constructor is used with the new operator, which allocates memory for a new object and the constructor initializes the new object. A constructor does not return a value to its caller. You can use a return statement without an expression inside a constructor. The return statement ends the constructor call and returns the controls to the caller.

Constructors are not considered members of the class. Like fields and methods, constructors also have an access level: public, private, protected, and package-level. The presence of the keyword public, private, and protected in defining them gives them public, private, and protected access level, respectively. Absence of any of these keywords specifies the package-level access.

A class can have more than one constructor. If a class has multiple constructors, they are called overloaded constructors. Since the name of the constructor must be the same as the simple name of the class, there is a need to differentiate one constructor from another. All constrictors of a class must differ from the others in the number, order, or type of parameters.

A constructor may call another constructor of the same class using the keyword this as if it were a method name. If a constructor of a class calls another constructor of the same class, the following rules must be met:

If you do not add a constructor to your class, the Java compiler adds one. Such as constructor is called a default constructor. The default constructor has the same access level as its class and it takes no parameters.

A class can also have one or more instance initializers to initialize objects of the class. An instance initializer is simply a block of code inside the body of a class, but outside any methods or constructors. Recall that a block of code is a sequence of legal Java statements enclosed within braces. An instance initializer does not have a name. Its code is simply placed inside an opening brace and a closing brace. When an object of a class is created, all instance initializers of the class are executed in textual order. Typically, instance initializers are used to initialize an object of an anonymous class.

You can define a class and its members final. If something is final, it means its definition or value, whatever it represents, cannot be modified. Final variables are used to define constants in Java. Compile-time constants are constants whose values are known when the program is compiled. Runtime constants are constants whose values are not known until the program is run.

A variable can be declared blank final, in which case the variable is declared final, but not assigned a value at the time of declaration. A blank final variable must be assigned a value before its value is read. A blank final instance variable must be initialized once in its instance initializers or constructors. You can declare a class variable as blank final. You must initialize a blank final class variable in one of the static initializers. If you have more than one static initializer for a class, you must initialize all the blank final class variables only once in one of the static initializers.

Java allows you to write true polymorphic code using generics in which code is written in terms of formal type parameters. A generic class is defined using formal type parameters. Formal type parameters are a list of comma-separated variable names placed in angle-brackets (<>) after the class name in the class declaration. Classes that take formal type parameters are also known as parameterized classes . The actual type parameters are specified when the parameterized classes are used.