Java include syntax that allows programers to create user-defined types. A user-defined type is defined in a class definition.
The general form of a class definition is as follows:
class className {
// fields
// constructors
// methods
// inner classes
}
An instance of a class is called an object.
Fields
A field is a variable declaration within a class definition.
Fields allow us to store within a single object various types of data. For example, suppose you want to store information about a box in a program, you could create three variables named height, width, and length. That’s simple enough. But by constructing a new type, lets name it Box, and adding fields to class definition, we can store the dimensions of a box within a single object.
class Box {
int height;
int width;
int length;
}
In the example above, we say the Box class has 3 fields named height, width, and length.
We can create an instance of a Box using the new keyword and invoking a constructor.
Box aBox = new Box();
When the new keyword is used, a new instance of that type (or object) is created in heap memory. Then a constructor is called which initializes the object. Finally, a reference (memory address) to that new object is stored in the variable on the left hand side of the assignment statement. Note that the object itself is not stored in the variable, but rather a reference to the object is stored in the variable.
When no constructor is included in a class definition, as in the above example, a default constructor is used which initializes all unassigned numeric, reference, and booloean fields to 0, null, and false respectively. So in the example above, the 3 fields of the object referenced by aBox are initialized to the value 0.
We can access the fields of the object using the reference to the object and the dot operator.
int volume = aBox.length * aBox.width * aBox.height;
We can modify the fields of an object also using the reference to the object and dot operator on the left hand side of an assignment operator (=).
aBox.height = 6;
aBox.width = 6;
aBox.length = 12;
You can optionally initialize the fields in the class definition so that when an instance of the class is created the fields have some initial value.
class Box {
int height = 0;
int width = 0;
int length = 0;
}
Final Fields
A field can be declared as final which prohibits it from being modified after the constructor is run. This implies the field is essentially a constant. Since it can’t be modified after the constructor’s code is executed, the field’s value has to be initialized either when it is declared or within a constructor. The former is usually the norm.
Final Reference Fields
It should be noted that when a field is declared final, the fields value can not be changed after the constructor is executed. If the field is a reference type, that implies that the field will always refer to the same object. This doesn’t prohibit modifying the object itself. Consider the following example:
class A {
int x = 0;
}
class Driver {
final static A obj = new A();
public static void main(String[] args) {
//obj = new A(); // error!
System.out.println(obj.x); // prints 0
obj.x = 10;
System.out.println(obj.x); // prints 10
}
}
So, although the reference stored in obj can not change, the properties of the object that obj references can be modified.
Constructors
As mentioned above, a constructor is a block of code that is executed to initialize a newly created class object. Constructors are defined using the following general form. Notice the constructor uses the name of the class in its definition.
ClassName (parameter-list) {
...
}
To continue the box example, we can include a parameterless constructor that initialize each of the fields of a newly created object to -1.
class Box {
int height;
int width;
int length;
Box() {
height = -1;
width = -1;
length = -1;
}
}
Overloading Constructors
A class can have multiple constructors so long as they don’t create ambiguity when determining which constructor is to be invoked. When we provide more than one constructor we say the constructor is overloaded.
In order to allow the creation of a Box object that has dimensions that are different than the default dimensions, we can include a constructor with parameters that will require the user to pass values into the constructor when creating a new instance of Box.
class Box {
int height;
int width;
int length;
Box() {
height = -1;
width = -1;
length = -1;
}
Box(int h, int w, int l) {
height = h;
width = w;
length = l;
}
}
To create instances of the above Box class we can either use the parameterless constructor or pass 3 integer values as arguments to use the second constructor.
Box aBox = new Box();
Box bBox = new Box(6, 12, 24);
To call the second constructor, arguments must be passed to the constructor and the types of the arguments must match the parameters in the constructor definition.
Lets look at the code within the second constructor. When the constructor is being executed, a local variable is created for each of the parameters; one named h, one named w, and the last named l. These local variables are initialized with the values of the arguments that are passed to the constructor: 6, 12, and 26. Then the statements inside the constructor’s block are executed which initializes the fields.
As mentioned earlier, when we create an instance of the class, a reference (memory address) to the new object is stored in the variable specified on the left hand side of the assignment statement. In the example above, aBox and bBox have different values because they hold different memory addresses to two different Box objects. We can check if two variables point to the same object in memory by using the comparison operators (==, !=).
if (aBox != bBox) {
System.out.println("aBox points to a different Box object than bBox");
}
This
When code inside a class definition is being executed, it is being executed for some particular instance of the class. The this keyword is used inside a class definition to refer to the specific instance of the class for which the code is executing.
For example, when we define a constructor (or method) we can use field names as identifiers in the parameter list. When we do, since parameters define local variables inside the constructor that are different from the field variables, the parameters that have field names hide the fields with same names. If we want to access an object’s fields when the fields are hidden, we can use the this keyword as shown below.
class Box {
int height;
int width;
int length;
Box(int height, int weight, int length) {
this.height = height;
this.width = width;
this.length = length;
}
}
The first statement in the constructor’s block sets the field named height equal to the value of the first argument passed into the constructor which is stored in the local variable named height.
Methods
A method is a block of code in a class definition that is executed on an instance of the class (aka object). When a programmer requests that the block of code in a method be executed on an object, we say the method is being called on the object.
A method definition includes a return type, followed by the name of the method, followed by a parameter list and a block of code.
Take for example the Box class below that contains the method named getHeight.
class Box {
int height;
int width;
int length;
Box(int h, int w, int l) {
height = h;
width = w;
length = l;
}
int getHeight() {
return height;
}
}
The method named getHeight simply returns the value currently being stored in the field named height of some object. Since the field named height stores an integer, the return type of the method is int.
Suppose we have a program that has created two boxes as shown below.
Box aBox = new Box(1,2,3);
Box bBox = new Box(5,5,5);
When we call a method we must call the method on an instance of the the method’s class. We call a method on an object by using the reference to the object and the dot operator as shown below.
int aBoxHeight = aBox.getHeight();
int bBoxHeight = bBox.getHeight();
In the example above, aBoxHeight holds the value 1 and bBoxHeight holds the value 5.
Methods can also receive input data through a parameter list as in the method named setHeight shown below.
class Box {
int height;
int width;
int length;
Box(int h, int w, int l) {
height = h;
width = w;
length = l;
}
int getHeight() {
return height;
}
void setHeight(int h) {
height = h;
}
}
The method named setHeight can be used to change the value of a Box object’s height field.
aBox.setHeight(10);
The method named setHeight doesn’t return any data, so we set the return type to void. The method requires the caller to pass in an integer. When the method is called, the value passed into the method is stored in a local variable named h. After the parameter has been initialized, the code block for the method is executed. Recall that methods are called on instances of the class. When the method’s block of code is executed on a particular instance of the class, the object’s height field is set equal to the value of the local variable named h.
As with constructors, we can use fields names in the parameter list of a method. When we do, the fields are hidden, but can be accessed in the method’s block by using the this keyword.
We can also overload methods. That is, we can include in our class more than one method with the same name, so long as there is no ambiguity as to which method is being called.
Getters and Setters
A method in a class that is defined to simply return the value of a field is called a getter. A method in a class that is defined to simply set the value of a field is called a setter. Block recommends (Item 14) that we use getters and setters (accessor methods) to access fields.
Garbage Collection
Recall that a variable of a user-defined type holds a reference to an object of that type. The reference is an address pointing to some area of heap memory. The memory that holds an object that is no longer referenced by any variable is automatically freed in a process called garbage collection. Garbage collection occurs sporadically, and may not occur at all when your program is running. But if memory is needed and there are objects that are no longer referenced, that memory will be freed by the garbage collector so that it can be reused.
finalize()
If a class definition includes a finalize() method, then before the garbage collector frees up the memory used by an object of that class, the garbage collector will call the finalize() method on the instance in memory. Since there is uncertainty as to when or if even an object will be garbage collected, it is not recommended to rely on a finalize() method to release resources. In fact, Bloch (Item 7) recommends we avoid using finalize() altogether.
