Classes,Methods and constructor in Java Lab # 5

LAB # 5

INTRODUCING CLASSES, METHODS AND

CONSTRUCTOR

OBJECTIVE:
To Study classes, methods and constructor.

THEORY:

5.1 DEFINING CLASSES

Class:

The definition of a class is to create objects of that class type — that is, to
create objects that incorporate all the components specified as belonging to
that class.

There are just two kinds of things that you can include in a class definition:

❑Fields— These are variables that store data items that typically differentiate
one object of the class from another. They are also referred to as data
members of a class.

❑Methods— These define the operations you can perform for the class — so
they determine what you can do to, or with, objects of the class.

Methods typically operate on the fields — the variables of the class. The fields
in a class definition can be of any of the primitive types, or they can be
references to objects of any class type, including the one that you are
defining. The methods in a class definition are named, self-contained blocks
of code that typically operate on the fields that appear in the class definition.

A class is declared by use of the class keyword. Notice that the general form
of a class does not specify a main( ) method. Java classes do not need to
have a main( ) method. You only specify one if that class is the starting point
for your program.

The general form of a class definition is shown here:

Object Oriented Programming - OOPs 1

Classes,Methods and constructor in Java Lab # 5

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 }
// ...
}

Fields in a Class Definition:

An object of a class is also referred to as an instance of that class. When you

create an object, the object will contain all the fields that were included in the
class definition. However, the fields in a class definition are not all the same
— there are two kinds.
❑Non-static fields, also called instance variables— Each object of the class
will have its own copy of each of the non-static fields or instance variables that
appear in the class definition. Each object will have its own values for each
instance variable. The name instance variable originates from the fact that an
object is an instance or an occurrence of a class, and the values stored in the
instance variables for the object differentiate the object from others of the
same class type. An instance variable is declared within the class definition in
the usual way, with a type name and a variable name, and can have an initial
value specified.
❑Static fields, also called class variables— A given class will have only one
copy of each of its static fields or class variables, and these will be shared
between and among all the objects of the class. Each class variable exists
even if no objects of the class have been created. Class variables belong to
the class, and they can be referenced by any object or class method, not just
methods belonging to instances of that class. If the value of a static field is
changed, the new value is available equally in all the objects of the class. This
is quite different from non-static fields, where changing a value for one object
does not affect the values in other objects. A static field must be declared
using the keyword static preceding the type name.
Look at Figure, which illustrates the difference between class variables and
instance variables

Object Oriented Programming - OOPs 2

Classes,Methods and constructor in Java Lab # 5

To define a class you use the keyword class followed by the name of the class,
followed by a pair of braces enclosing the details of the definition along with
fields. Let’s consider a concrete example to see how this works in practice:

5.2 DEFINING METHODS:

A method is a self-contained block of code that has a name, and has the
property that it is reusable — the same method can be executed from as
many different points in a program as you require. Methods also serve to
break up large and complex calculations that might involve many lines of code
into more manageable chunks.
The basic structure of a method is shown in Figure

Object Oriented Programming - OOPs 3

Classes,Methods and constructor in Java Lab # 5

Returning from a Method:

To return a value from a method when its execution is complete you use a
return statement. The value return_value that is returned by the method can
be any expression that produces a value of the type specified for the return
value in the declaration of the method. For example:

If a method does not return a value, you can just use the keyword return by
itself to end execution of the method:

5.3 CONSTRUCTORS

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 immediately after the
object is created, before the new operator completes. Constructors look a
little strange because they have no return type, not even void.

When you create an object of a class, a special kind of method called a

constructor is always invoked. If you don’t define any constructors for your
class, the compiler will supply a default constructor in the class, which does
nothing. The default constructor is also described as the no-arg constructor
because it requires no arguments to be specified when it is called.

A constructor has two special characteristics that differentiate it from other

class methods:

❑A constructor never returns a value, and you must not specify a return type
— not even of type void.

Object Oriented Programming - OOPs 4

Classes,Methods and constructor in Java Lab # 5

❑A constructor always has the same name as the class.:

The Default Constructor:

As I said, if you don’t define any constructors for a class, the compiler will
supply a default constructor that has no parameters and does nothing. Before
you defined a constructor for the Sphere class, the compiler would have
supplied one, defined like this

To see a practical example you could add a constructor to the Sphere class
definition

class Sphere {

static final double PI = 3.14;//Class variable that has fixed value

static int count = 0; // Class variable to count objects

// Instance variables
double radius; // Radius of a sphere

double xCenter; // 3D coordinates

double yCenter; // of the center
double zCenter; // of a sphere

// Static method to report the number of objects created

static int getCount()
{
return count; // Return current object count
}

// Instance method to calculate

volumedouble volume() {
return 4.0/3.0*PI*radius*radius*radius;
}

Object Oriented Programming - OOPs 5

Classes,Methods and constructor in Java Lab # 5

Creating Objects of a Class:

When you declare a variable of type Sphere with the following statement:

no constructor is called because no object is created. All you have created at

this point is the variable ball, which can store a reference to an object of type
Sphere, if and when you create one. Figure shows this.

As just explained, when you create a class, you are creating a new data type.
You can use this type to declare objects of that type. However, obtaining
objects of a class is a two-step process.

 First, you must declare a variable of the class type. This variable does
not define an object. Instead, it is simply a variable that can refer to an
object.
 Second, you must acquire an actual, physical copy of the object and
assign it to that variable. You can do this using the new operator. The
new operator dynamically allocates (that is, allocates at run time)
memory for an object and returns a reference to it. This reference is,
more or less, the address in memory of the object allocated by new.
This reference is then stored in the variable. Thus, in Java, all class
objects must be dynamically allocated.

you will recall from the discussion of String objects and arrays that the variable
and the object it references are distinct entities. To create an object of a class
you must use the keyword new followed by a call to a constructor. To initialize ball
with a reference to an object, you could write:

Object Oriented Programming - OOPs 6

Classes,Methods and constructor in Java Lab # 5

LAB TASK

1. Write a program that create two classes one is Power_law another is

the main method class. Power_law class contains current, voltage and
power fields in integer datatype, and a method to calculate power and
display the output.

2. Write a program that creates two classes one is Student another is the
main method class. student contains private fields of roll-no, semester,
GPA, and use a constructor and a method to get and show the above
information of three students using get and show method in java.

Object Oriented Programming - OOPs 7