Explain Class Fundamentals In Java, What Is Class In Java
In This Topic & Blog Having Any Query Then Post your Comment and Suggestion Below
Class Fundamentals
Classes have been used since the beginning of this book. However, until now, only the most
rudimentary form of a class has been used. The classes created in the preceding chapters
primarily exist simply to encapsulate the
main( )
method, which has been used to demonstrate
the basics of the Java syntax. As you will see, classes are substantially more powerful than the
limited ones presented so far.
Perhaps the most important thing to understand about a class is that it defines a new data
type. Once defined, this new type can be used to create objects of that type. Thus, a class is
a template for an object, and an object is an instance of a class. Because an object is an instance
of a class, you will often see the two words object and instance used interchangeably.
The General Form of a Class
When you define a class, you declare its exact form and nature. You do this by specifying the
data that it contains and the code that operates on that data. While very simple classes may
contain only code or only data, most real-world classes contain both. As you will see, a class’
code defines the interface to its data.
A class is declared by use of the
class
keyword. The classes that have been used up to this
point are actually very limited examples of its complete form. Classes can (and usually do)
get much more complex. A simplified general form of a
class
definition is shown here:
class classname {
type instance-variable1 ;
type instance-variable2 ;
105
// ...
type instance-variableN ;
type methodname1 ( parameter-list ) {
// body of method
}
type methodname2 ( parameter-list ) {
// body of method
}
// ...
type methodnameN ( parameter-list ) {
// body of method
}
}
The data, or variables, defined within a
class
are called instance variables. The code is
contained within methods. Collectively, the methods and variables defined within a class are
called members of the class. In most classes, the instance variables are acted upon and accessed
by the methods defined for that class. Thus, as a general rule, it is the methods that determine
how a class’ data can be used.
Variables defined within a class are called instance variables because each instance of the
class (that is, each object of the class) contains its own copy of these variables. Thus, the data
for one object is separate and unique from the data for another. We will come back to this point
shortly, but it is an important concept to learn early.
All methods have the same general form as
main( )
, which we have been using thus far.
However, most methods will not be specified as
static
or
public
.
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. Further, applets don’t
require a
main( )
method at all
Simple Class
Let’s begin our study of the class with a simple example. Here is a class called
Box
that defines
three instance variables:
width height
,
, and
depth
.
Currently,
Box
does not contain any
methods (but some will be added soon).
class Box {
double width;
double height;
double depth;
}
As stated, a class defines a new type of data. In this case, the new data type is called
Box
.
You will use this name to declare objects of type
Box
.
It is important to remember that a
class
declaration only creates a template; it does not create an actual object. Thus, the preceding
code does not cause any objects of type
Box
to come into existence.
To actually create a
Box
object, you will use a statement like the following:
Box mybox = new Box(); // create a Box object called mybox
After this statement executes,
mybox
will be an instance of
Box
.
Thus, it will have “physical”
reality. For the moment, don’t worry about the details of this statement.
As mentioned earlier, each time you create an instance of a class, you are creating an object
that contains its own copy of each instance variable defined by the class. Thus, every
Box
object will contain its own copies of the instance variables
width height
,
, and
depth
. T
o
access these variables, you will use the dot (.) operator. The dot operator links the name of the
object with the name of an instance variable. For example, to assign the
width
variable of
mybox
the value 100, you would use the following statement:
mybox.width = 100;
This statement tells the compiler to assign the copy of
width
that is contained within the
mybox
object the value of 100. In general, you use the dot operator to access both the instance
variables and the methods within an object.
Here is a complete program that uses the
Box
class:
/* A program that uses the Box class.
Call this file BoxDemo.java
*/
class Box {
double width;
double height;
double depth;
}
// This class declares an object of type Box.
class BoxDemo {
public static void main(String args[]) {
Box mybox = new Box();
double vol;
// assign values to mybox's instance variables
mybox.width = 10;
mybox.height = 20;
mybox.depth = 15;
// compute volume of box
vol = mybox.width * mybox.height * mybox.depth;
System.out.println("Volume is " + vol);
}
}
You should call the file that contains this program
BoxDemo.java
, because the
main( )
method
is in the class called
BoxDemo
, not the class called
Box
.
When you compile this program, you
will find that two
.class
files have been created, one for
Box
and one for
BoxDemo
. The Java
compiler automatically puts each class into its own
.class
file. It is not necessary for both the
Box
and the
BoxDemo
class to actually be in the same source file. You could put each class
in its own file, called
Box.java
and
BoxDemo.java
, respectively.
To run this program, you must execute
BoxDemo.class
. When you do, you will see the
following output:
Volume is 3000.0
As stated earlier, each object has its own copies of the instance variables. This means that
if you have two
Box
objects, each has its own copy of
depth width
,
, and
height
.
It is important
to understand that changes to the instance variables of one object have no effect on the instance
variables of another. For example, the following program declares two
Box
objects:
// This program declares two Box objects.
class Box {
double width;
double height;
double depth;
}
class BoxDemo2 {
public static void main(String args[]) {
Box mybox1 = new Box();
Box mybox2 = new Box();
double vol;
// assign values to mybox1's instance variables
mybox1.width = 10;
mybox1.height = 20;
mybox1.depth = 15;
/* assign different values to mybox2's
instance variables */
mybox2.width = 3;
mybox2.height = 6;
mybox2.depth = 9;
// compute volume of first box
vol = mybox1.width * mybox1.height * mybox1.depth;
System.out.println("Volume is " + vol);
// compute volume of second box
vol = mybox2.width * mybox2.height * mybox2.depth;
System.out.println("Volume is " + vol);
}
}
The output produced by this program is shown here:
Volume is 3000.0
Volume is 162.0