Abstract Classes

As with object-oriented programming, declaring abstract concepts might be desired, but there is no possibility that you can create an instance of same. For example, the abstract concept of numbers is represented by Number class available with the java.lang package. The Number class serves as a model for numbers used in programs but is impossible to create the generic object.

The Number class is parent class of number of other number classes like Integer and double which implements specific types of numbers. The abstracted class represented by the number class, which implements abstract concepts. Abstract classes can be subclassed but it cannot have instance of it.

If you are declaring an abstract class, Use keyword ‘abstract’ just before ‘class’ keyword. This tells compiler that you are declaring an abstract class. In syntax form:

abstract class class_name {

. . .

}

If you try to create instance of an abstract class, a compiler will would refuse to compile the program and returns an error message. For example, a declaration written as the following can produce an error due to the instantiated abstract class:

AbstractTest.java:6: class class_name is an abstract class……..

1 error

Abstract Methods

Methods that do not have implementation which are contained in abstract class are called Abstract methods. The abstract class can define an interface which can be used for programming using subclasses. The method declarations for all the necessary methods to implement the programming interface are stated on the subclasses.

In an object-oriented program, you may create circles, rectangles, Bezier and lines. These graphing objects have some similarities such as state and behavior. The state of the object can be defined through its position and bounding box. The behavior may be stated to move, resize or draw the object. These shared properties can be declared to inherit from a single parent object which can be defined as the class GraphicObject.

On the other hand, the objects are different depending upon what shape should be drawn.  The process of drawing rectangle is different from the one used to draw a circle. The following example clearly shows the properties of an abstract superclass.

The GraphicObject should be declared to create member variables and methods and to be shared with children classes. The superclass will have move_To(), current_position methods and are shared by all subclasses. There are other abstract methods that are declared by the abstract class GraphicObject but implemented in different ways. Such abstract methods is the draw() method, which has no default implementation but should be implemented in all subclasses. Putting it in syntax form, the class GraphicObject would appear as the following:

abstract class Example_of_Graphic_Object {

int x_var, y_var;

. . .

void move_To(int newX_var, int newY_var) {

. . .

}

abstract void draw_shape();

}

A non-abstract subclass of the class GraphicObject such as Rectangle_class and Circle_class should provide the implementation for the draw() method.

class Circle_class extends Example_of_Graphic_Object {

void draw_shape() {

. . .

}

}

class Rectangle_class extends Example_of_Graphic_Object {

void draw_shape() {

. . .

}

}

The abstract class may or may not contain an abstract method. However, any class containing an abstract method or does not have an implementation for the declared abstract methods in the superclasses should be treated as abstract class.

Some of the features of the static member class are:

• The static member class is always defined with static modifier. This way static member class becomes equivalent to all other class members which are declared with static modifier.
• A static member class can use access control modifiers, without any alteration in the meaning of these modifiers.
• The static member class can access all the static members of containing class (private member as well). ses.
• The static member class can not be associated instances of the containing class.

However, the declaration of the static member class imposes certain restrictions too. These are:

• The static member class and its containing class should have different names.
• These classes can be defined only within the static member classes or Top-level classes.

Also, in case the static member classes need to be used by classes outside the containing classes, this class is used by combining its name and name inner class.

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.

The Java 1.1 supports instance initializers in the classes. An instance initializer is similar to static initializers. However, it is used to initialize an object instead of an entire class and does not support the keyword static. A class can support multiple initializers, which can be contained anywhere in the definition of the field or method.

Instance initializers are used to initialize arrays or other fields requiring complex initialization. They can also be used to locate the initialization code placed next to the field, instead of separating it off in a constructor method.  However, these initializes are rarely used in the actual programs.

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.

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; }

// This constructor uses this () to invoke the constructor above

public Circle_class() { this(1.0); }

The this()keyword is used to invoke methods by calling another constructors of the class. Using the ‘this’ keyword avoids repetition of the code in case of using multiple constructors. This is particularly useful in cases where a large number of constructors share a large amount of initialization code.