Advanced JAVA | Java HowTo Guide

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 – Objects

By Java Tutor, on October 15th, 2011

In the Java programming language, unlike the C language which uses a structure to create a new complex data types, classes are used to define a new data type. For example, when a new class animal is created in Java, it also implicitly creates an animal data type.

The use and assignment of the data item depends on how it was defined. For example, an item of animal data type can be assigned to a variable of type animal. It can also be passed to as a class that accepts animal as an argument.

The object-oriented programming language such as Java does not only use a data type as a simple attribute. In this type of programming, a class is represented as a hierarchy while a subclass can be shown as a special kind or a subtype of its parent class. Not only this, reference types and class are related to each other in some ways. Also, child classes always extend to their parent class and have the same functionality as the parent.

Continuing with the example we saw above, a lion class can extend to the animal class, this new type Lion is considered in the java language as a subtype of the type animal. The objects of the Lion class can also be used in places where the objects of animal class can be used. Therefore, an object of type Lion is assignable to the variable of type Animal. This assignment of classes is known as subtype polymorphism and forms a primary feature of any object-oriented language called Java.

Going back to the Reference types, these types are always accessed by a reference, which is nothing but a handle or the name of an object. The variable of a reference type holds a reference to an object of its type or of a subtype. Similar to a pointer in C or C++ a reference is a data type which is enforced strictly and can’t be examined directly. These values are static in nature and cannot be changed except when assigned to a particular object. The reference values are automatically dereferenced in any place where they are referenced. Continue reading JAVA – Objects

JAVA – Getter/Accessors and Setters/Modifiers

By Java Tutor, on October 7th, 2011

In Java, robust classes and components are based on the object-oriented principles of encapsulation and information hiding. This approach of information hiding can be further extended by using the appropriate assessor methods.

Accessor is member functions used in java to directly manipulate the value of any field. These accessor methods are of two types:

Setters
Getters

A setter is used to modify the value of a field. On the other hand, a getter is used to obtain the field’s value. Execution of assessors involves a minimal overhead to your program’s code. Not only this, if these assessors are not used in your code, the loss of performance is often very small when compared to other factors such as databases not designed well.

However, the use of accessor benefits the code too by hiding the implementation details and by increasing the robustness of your code. A good programmer can increase the maintainability of the code by defining a getter and a setter to access a field. This leads to minimizing the effort for making any changes in the code. The getters and setters enable a programmer to encapsulate important:

Business rules
Transformation logic
Validation logic applicable to the data fields of the code.

The example given below depicts the use of the setter and getter functions for the Address_of_your_Home field of the Employee class Continue reading JAVA – Getter/Accessors and Setters/Modifiers

Java HowTo Guide

Categories

Archives

JAVA – Defining Multiple Constructors

JAVA – Defining a Constructor

JAVA – Creating and Initializing Objects

JAVA – Objects

JAVA – Getter/Accessors and Setters/Modifiers

Recent Posts

Blogroll