Java class
fundamentals
Mr. M.R.
Solanki
Sr. Lecturer, Information Technology,
[email protected]
SBMP
Learning Outcomes
Students will be able to:
• Write a class in Java
• Instantiate object in Java
• Add member methods in a class
• Introduce constructors in Java
• Describe Garbage Collection process
Defining a class in Java
class syntax
A class is declared by use of the class keyword.
class classname {
type instance-variable1;
type instance-variable2;
type instance-variableN;
type methodname1(parameter-list) {
// body of method
}
type methodname2(parameter-list) {
// body of method
}
type methodnameN(parameter-list) {
// body of method
}
} //end of class
“
# Java classes do not need to have a main( )
method
# You only specify one if that class is the
starting point for your program
# applets, don’t require a main( ) method at
all
class syntax
A class example
class Box
{
double width;
double height;
double depth;
}
Instantiating an object
in Java
Creating Objects
Obtaining objects of a class is a two-step process:
1. Declare a variable of the class type i.e.
reference
This variable does not define an object.
It is simply a variable that can refer to an
object
We can not apply mathematical operators
i.e. + and – on reference (as allowed in case of
pointer in C/C++)
We can assign one reference to other
reference variable
Syntax: classname ref;
Example: Box mybox;
Creating Objects
2. Acquire an actual, physical copy of the object
and assign it to that variable:
It is performed using new operator.
The new operator dynamically allocates (at run
time) memory
for an object and returns its reference.
This reference is the address of the object
allocated by new in the memory (RAM).
This reference is then stored in the variable
Syntax: ref = new classname();
Example: mybox = new Box();
Creating Objects
RAM
Creating Objects
declaration
Variables
We can assign one reference to other reference as
below:
Box b1 = new Box();
Box b2 = b1;
b1 and b2 will both refer to the same object.
The assignment of b1 to b2 did not allocate any
memory or copy any part of the original object.
It simply makes b2 refer to the same object as
does b1
Thus, any changes made to the object through b2
will affect the object to which b1 is referring,
since they are the same object
“
# Although b1 and b2 both refer to the same
object, they are not linked in any other way.
For example, If we assign b1 with other object
reference or with null value, it will unhook itself
from original object without affecting the original
object or b2.
Box b1 = new Box();
Box b2 = b1;
// ...
b1 = null;
Here, b1 has been set to null, but b2 still
points to the original object.
Adding method in a
class
Adding Methods
type name(parameter-list) {
// body of method
}
(i) type : type of data returned by the
method.
This can be any valid type
If the method does not return a value, its
return type must be void.
(ii) name : name of the method is specified
by name.
This can be any legal identifier other than
those already used by other items within the
current scope.
Adding Methods
type name(parameter-list) {
// body of method
}
(iii) parameter-list: is a sequence of type
and identifier pairs separated by commas
Parameters are essentially variables
that receive the value of the arguments
passed to the method when it is called
If the method has no parameters,
then the parameter list will be empty.
Methods that have a return type other than
void return a value to the calling routine using the
following form of the return statement:
return value;
Here, value is the value returned.
Adding Methods
Methods that have a return type other than void
return a value to the calling routine using the
following form of the return statement:
return value;
Here, value is the value to be returned.
Adding a Method in Box class
Adding a Method in Box class
statement
statement
about returning values:
“
There are two important things to understand
The type of data returned by a method must be
compatible with the return type specified by the
method. For example, if the return type of some
method is boolean, you could not return an
integer.
The variable receiving the value returned by a
method (i.e. vol, in this case) must also be
compatible with the return type specified for the
method.
While initializing data members in main(), creates 2
“
problems:
1. It is clumsy and error prone.
Example, It would be easy to forget to set a
dimension.
2. In well-designed Java programs, instance
variables should be accessed only through
methods defined by their class. (Encapsulation)
Initializing instance members using setter
method
We can use setter method in Java to initialize the instance
data members of a class:
Initializing instance members using setter
method
Exercise
“
Write the previous program by taking user input
from key board using Scanner class.
Introducing Constructor
in Java
Introducing Constructors
Setter methods are to be called explicitly to
initialize instance data members of an object.
Java allows objects to initialize themselves when
they are created.
This automatic initialization is performed
through the use of a
constructor.
Constructor Properties
A constructor initializes an object immediately
upon creation.
It has the same name as the class in which it
resides and is syntactically similar to a method.
Once defined, the constructor is automatically
called when the object is created, before the
new operator completes.
Constructors don’t have return type, not even
void (the implicit return type of a class’
constructor is the class type itself).
It is the constructor’s job to initialize the
internal state of an object so that the code
Introducing Constructors
Introducing Constructors
provides an
+)
“
Note: (i) If we don’t provide a constructor, Java
automatic constructor (same as C+
(ii) The default values assigned to data
members of a class as per data type are as below:
integer group -> 0
floating point group -> 0.0
boolean -> false
char-> \u0000 or null (‘\0’)
reference variable -> null
Introducing Constructors
Introducing Constructors
Parameterized Constructors
Initialization of data members in parameter less
constructor is not effective way.
In this case, every object’s data is initialized
with the same values.
The easy solution is to add parameters to the
constructor (same as C++)
It is similar to passing parameters to a method.
Parameterized Constructors
The this keyword
Sometimes a method will need to refer to the
object that invoked it.
To allow this, Java defines this keyword.
this can be used inside any method to refer to the
current object
this stores a reference to the object who has
invoked the method presently.
// A redundant use of this
Box(double w, double h, double d)
{
this.width = w;
this.height = h;
this.depth = d;
}
Instance variable Hiding
We can have local variables, i.e. formal
parameters to methods, which overlap with the
names of the class’ instance variables.
When a local variable has the same name as an
instance variable, the local variable hides the
instance variable (local wins)
This is why width, height, and depth were not
used as the names of the parameters to the Box(
) constructor inside the Box class.
Solution:
// Use this to resolve name-space
collisions.
Box(double width, double height, double
depth) {
this.width = width;
this.height = height;
this.depth = depth;
Working of this
Working of this
Garbage Collection
Garbage Collection
In some languages, such as C++, dynamically
allocated objects must be manually released by
use of a delete operator.
Java takes a different approach; it handles
deallocation for you automatically.
The technique that accomplishes this is called
garbage collection.
Garbage Collection
Working:
When no references to an object exist, that
object is assumed to be no longer needed, and
the memory occupied by the object can be
reclaimed.
There is no explicit need to destroy objects as in
C++. Garbage collection only occurs sporadically
(if at all) during the execution of your program
It will not occur simply because one or more
objects exist that are no longer used
Thanks!
Any questions?
You can find me at:
[email protected] Credits
Java The Complete Reference, Ninth E
dition, Herbert Schildt
