Building Blocks | Java HowTo Guide

JAVA – Initializer blocks

By Java Tutor, on November 13th, 2011

As you have already learnt, the initialization expressions of the fields and the code of the constructor methods are used to initialize the objects. A class contains a class initialization method. Though they are both the same, there is only one difference. The class initialization method needs to be explicitly defined in the body of this method. You can write arbitrary codes for initializing the class fields in the Java programming language. This is done using a construct known as a static initializer.

A static initializer is nothing but the keyword static followed by a block of code enclosed in curly braces. This keyword can appear in a class definition wherever a field or method definition appears. A class can use multiple initializers where the body of each initializer is contained into the class initialization method. The initializer’s body also contains the static field initialization expressions. A static initializer is similar to a class method. However, it cannot make use of the this keyword, any instance fields or instance methods of the class. Continue reading JAVA – Initializer blocks

JAVA – Field Defaults and Initializers

By Java Tutor, on November 8th, 2011

As you have seen earlier, all the fields do not need to be initialized. The member fields of a class are initialized automatically, unlike local variables that need to be explicitly initialized. For example, the primitive data type fields are initialized to a default value of false or zero automatically. Similarly, all fields of reference data types are initialized to null. Java compiler automatically performs this job depending on the default value of a field, and this condition implies to both instance fields and class fields.

Now let’s look at a variable declaration. The variable is declared within a Java statement and is initialized when the Java statement is executed. Unlike variables in a method, the field declarations are not a part of any particular method. These cannot be therefore executed as individual statements.

On the other hand, the Java compiler automatically generates initialization code that is instance-free. This instance-free initialization code is stored in the class constructor or constructors. The order of the constructor in the source code determines the manner in which it appears in the constructor. Accordingly, the field initializer can use all the initial values of the fields declared before it. If a constructor starting with the this() keyword makes a call to another constructor, the field initialization code is not displayed in the first constructor. Conversely, the method initialization is done by the constructor invoked by the this() call.

JAVA – Defining Multiple Constructors

By Java Tutor, on November 1st, 2011

Certain objects can be initialized in many different ways and can also be used in multiple ways. For example, in the Circle class that we all are familiar with, the radius of the circle can be initialized to a specified value or a reasonable default value. Therefore, we can use multiple constructors if there are many instances of fields in a program. Let’s see how we can define two constructors for the Circle class:

public Circle_class() { radius_var1 = 0.54; }

public Circle_class(double radius_var1) { this.radius_var1 = radius_var1;}

We can define as many constructors as we want for a particular class. However, each constructor should have its own parameter list. The Java compiler selects a constructor on its own based on the type of parameters and the number and type of arguments supplied by you.

Calling One Constructor from Another

The ‘this’ keyword as defined above is used specifically in the case a class has multiple constructors. The ‘this’ keyword is then used to invoke one of the other constructors of the same class. In other words, we can rewrite the two previous Circle constructors as follows:

// This is an example of basic constructor: It is used to initialize the radius

public Circle_class(double radius_var1) { this.radius_var1 = radius_var1; } Continue reading JAVA – Defining Multiple Constructors

JAVA – Defining a Constructor

By Java Tutor, on October 26th, 2011

Let’s define a constructor for the Circle class example we just saw. This constructor enables you to specify the radius of the new Circle_class object. Also, the constructor uses a ‘this’ parameter that distinguishes the method parameter from a instance field, both having the same name.

public class Circle_class

{

public static final double PI_constant = 3.14159; // Here, PI is a constant

public double radius_var1; // Here, radius_var1 is field that holds the radius of the circle

// The constructor method used to initialize the radius field

public Circle_class(double radius_var1) { this.radius_var1 = radius_var1; }

// The instance methods used to compute values based on the radius

public double circumference_of_circle()

{ return 2 * PI_constant * radius_var1; }

public double area_of_circle() { return PI_constant * radius_var1*radius_var1; }

}

A default constructor supplied by the Java compiler is explicitly initialized using the above syntax:

Circle_class c1 = new Circle_class();

c1.radius_var1 = 0.54;

In this new constructor radius_var1, the constructor is initialized at the time of object creation. This is displayed below:

Circle_class c1 = new Circle_class(0.54);

Some important points that need to be kept in mind when naming, declaring, and writing constructors are:

The name of the constructor is always the same as the name of the class to which it belongs.
The constructor is always declared without any return type. It is not even followed by the keyword void.
The body of a constructor is used to initialize the ‘this’ object.
A constructor does not return any value, not even ‘this’.

JAVA – Creating and Initializing Objects

By Java Tutor, on October 21st, 2011

The Java programming language uses constructors to create and initialize objects. Let us see a simple Circle class -

Circle_class c1 = new Circle_class();

In the above code, the parenthesis is used to call a method. In the Java programming language, every class uses a constructor. A constructor is nothing but a method created by the same name as the class, to which it belongs. And can you guess what it is used for? Yes, the constructor object is used for initializing a new object. The Java class provides a default constructor that neither takes any arguments nor does it perform any initialization for the Circle class we just created.

In the example of the code we just saw, the new operator creates a new and uninitialized instance of the Circle class. The program then calls the constructor and implicitly passes a new object to it, with the help of the ‘this’ operator that we saw earlier. At the same time, it explicitly passes the arguments between the parentheses. The constructor then uses these arguments to perform any necessary initialization.

Java HowTo Guide

Categories

Archives

JAVA – Initializer blocks

JAVA – Field Defaults and Initializers

JAVA – Defining Multiple Constructors

JAVA – Defining a Constructor

JAVA – Creating and Initializing Objects

Recent Posts

Blogroll