{"id":3444,"date":"2019-06-20T11:42:33","date_gmt":"2019-06-20T11:42:33","guid":{"rendered":"http:\/\/softlect.in\/?p=3444"},"modified":"2019-06-20T11:59:33","modified_gmt":"2019-06-20T11:59:33","slug":"java-classes","status":"publish","type":"post","link":"http:\/\/softlect.com\/index.php\/java-classes\/","title":{"rendered":"Java Classes"},"content":{"rendered":"

<\/a>Introducing Classes<\/strong><\/h1>\n

 <\/p>\n

The class is at the core of Java. The class forms the basis for object-oriented programming in Java. Any concept you wish to implement in a Java program must be encapsulated within a class.<\/p>\n

 <\/p>\n

<\/a>Class Fundamentals<\/strong><\/h2>\n

The classes created in the preceding chapters primarily exist simply to encapsulate the main( ) <\/strong>method, which has been used to demonstrate the basics of the Java syntax. 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 <\/em>for an object, and an object is an instance <\/em>of a class.<\/p>\n

<\/a>The General Form of a Class<\/h3>\n

When defining a class, declare its exact form and nature. This is done 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. A class is declared by use of the class <\/strong>keyword. The general form of a class <\/strong>definition is shown here:<\/p>\n

 <\/p>\n

class classname <\/em>{<\/p>\n

type instance-variable1<\/em>;<\/p>\n

type instance-variable2<\/em>;<\/p>\n

\/\/ …<\/p>\n

type instance-variableN<\/em>;<\/p>\n

type methodname1<\/em>(parameter-list<\/em>) {<\/p>\n

\/\/ body of method<\/p>\n

}<\/p>\n

type methodname2<\/em>(parameter-list<\/em>) {<\/p>\n

\/\/ body of method<\/p>\n

}<\/p>\n

\/\/ …<\/p>\n

type methodnameN<\/em>(parameter-list<\/em>) {<\/p>\n

\/\/ body of method<\/p>\n

}<\/p>\n

}<\/p>\n

 <\/p>\n

The data, or variables, defined within a class <\/strong>are called instance variables. <\/em>The code is contained within methods. <\/em>Collectively, the methods and variables defined within a class are called members <\/em>of the class. In most classes, the instance variables are acted upon and accessed by the methods defined for that class. Thus, it is the methods that determine how a class\u2019 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. Java classes do not need to have a main( ) <\/strong>method. You only specify one if that class is the starting point for your program.<\/p>\n

<\/a>A Simple Class<\/h3>\n

Here is a class called Box <\/strong>that defines three instance variables: width<\/strong>, height<\/strong>, and depth<\/strong>. Currently, Box <\/strong>does not contain any methods.<\/p>\n

 <\/p>\n

class Box {<\/p>\n

double width;<\/p>\n

double height;<\/p>\n

double depth;<\/p>\n

}<\/p>\n

 <\/p>\n

a class defines a new type of data. In this case, the new data type is called Box<\/strong>. You will use this name to declare objects of type Box<\/strong>. It is important to remember that a class <\/strong>declaration only creates a template; it does not create an actual object. Thus, the preceding code does not cause any objects of type Box <\/strong>to come into existence. To actually create a Box <\/strong>object, you will use a statement like the following:<\/p>\n

Box mybox = new Box(); \/\/ create a Box object called mybox<\/p>\n

 <\/p>\n

After this statement executes, mybox <\/strong>will be an instance of Box<\/strong>. Again, 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 <\/strong>object will contain its own copies of the instance variables width<\/strong>, height<\/strong>, and depth<\/strong>. To access these variables, you will use the dot <\/em>(.) operator. The dot operator links the name of the object with the name of an instance variable. For example, to assign the width <\/strong>variable of mybox <\/strong>the value 100, you would use the following statement:<\/p>\n

 <\/p>\n

mybox.width = 100;<\/p>\n

 <\/p>\n

This statement tells the compiler to assign the copy of width <\/strong>that is contained within the mybox <\/strong>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 <\/strong>class:<\/p>\n

 <\/p>\n

\/* A program that uses the Box class.<\/p>\n

Call this file BoxDemo.java<\/p>\n

*\/<\/p>\n

class Box {<\/p>\n

double width;<\/p>\n

double height;<\/p>\n

double depth;<\/p>\n

}<\/p>\n

\/\/ This class declares an object of type Box.<\/p>\n

class BoxDemo {<\/p>\n

public static void main(String args[]) {<\/p>\n

Box mybox = new Box();<\/p>\n

double vol;<\/p>\n

\/\/ assign values to mybox’s instance variables<\/p>\n

mybox.width = 10;<\/p>\n

mybox.height = 20;<\/p>\n

mybox.depth = 15;<\/p>\n

\/\/ compute volume of box<\/p>\n

vol = mybox.width * mybox.height * mybox.depth;<\/p>\n

System.out.println(“Volume is ” + vol);<\/p>\n

}<\/p>\n

}<\/p>\n

 <\/p>\n

You should call the file that contains this program BoxDemo.java<\/strong>, because the main( ) <\/strong>method is in the class called BoxDemo<\/strong>, not the class called Box<\/strong>. When you compile this program, you will find that two .class <\/strong>files have been created, one for Box <\/strong>and one for BoxDemo<\/strong>. The Java compiler automatically puts each class into its own .class <\/strong>file. It is not necessary for both the Box <\/strong>and the BoxDemo <\/strong>class to actually be in the same source file. You could put each class in its own file, called Box.java <\/strong>and BoxDemo.java<\/strong>, respectively. To run this program, you must execute BoxDemo.class<\/strong>. When you do, you will see the following output:<\/p>\n

 <\/p>\n

Volume is 3000.0<\/p>\n

 <\/p>\n

As stated earlier, each object has its own copies of the instance variables. This means that if you have two Box <\/strong>objects, each has its own copy of depth<\/strong>, width<\/strong>, and height<\/strong>. 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 <\/strong>objects:<\/p>\n

 <\/p>\n

\/\/ This program declares two Box objects.<\/p>\n

class Box {<\/p>\n

double width;<\/p>\n

double height;<\/p>\n

double depth;<\/p>\n

}<\/p>\n

class BoxDemo2 {<\/p>\n

public static void main(String args[]) {<\/p>\n

Box mybox1 = new Box();<\/p>\n

Box mybox2 = new Box();<\/p>\n

double vol;<\/p>\n

\/\/ assign values to mybox1’s instance variables<\/p>\n

mybox1.width = 10;<\/p>\n

mybox1.height = 20;<\/p>\n

mybox1.depth = 15;<\/p>\n

\/* assign different values to mybox2’s<\/p>\n

instance variables *\/<\/p>\n

mybox2.width = 3;<\/p>\n

mybox2.height = 6;<\/p>\n

mybox2.depth = 9;<\/p>\n

\/\/ compute volume of first box<\/p>\n

vol = mybox1.width * mybox1.height * mybox1.depth;<\/p>\n

System.out.println(“Volume is ” + vol);<\/p>\n

\/\/ compute volume of second box<\/p>\n

vol = mybox2.width * mybox2.height * mybox2.depth;<\/p>\n

System.out.println(“Volume is ” + vol);<\/p>\n

}<\/p>\n

}<\/p>\n

 <\/p>\n

The output produced by this program is shown here:<\/p>\n

Volume is 3000.0<\/p>\n

Volume is 162.0<\/p>\n

 <\/p>\n

<\/a>Declaring Objects<\/strong><\/h2>\n

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 <\/em>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 <\/strong>operator. The new <\/strong>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<\/strong>. This reference is then stored in the variable. Thus, in Java, all class objects must be dynamically allocated. the following is used to declare an object of type Box<\/strong>:<\/p>\n

 <\/p>\n

Box mybox = new Box();<\/p>\n

 <\/p>\n

This statement combines the two steps just described. It can be rewritten like this to show each step more clearly:<\/p>\n

 <\/p>\n

Box mybox; \/\/ declare reference to object<\/p>\n

mybox = new Box(); \/\/ allocate a Box object<\/p>\n

 <\/p>\n

The first line declares mybox <\/strong>as a reference to an object of type Box<\/strong>. After this line executes, mybox <\/strong>contains the value null<\/strong>, which indicates that it does not yet point to an actual object. Any attempt to use mybox <\/strong>at this point will result in a compile-time error. The next line allocates an actual object and assigns a reference to it to mybox<\/strong>. After the second line executes, you can use mybox <\/strong>as if it were a Box <\/strong>object. But in reality, mybox <\/strong>simply holds the memory address of the actual Box <\/strong>object. The effect of these two lines of code is depicted in Figure 6-1.<\/p>\n

 <\/p>\n

<\/a>A Closer Look at new<\/h3>\n

 <\/p>\n

As just explained, the new <\/strong>operator dynamically allocates memory for an object. It has this general form:<\/p>\n

 <\/p>\n

class-var <\/em>= new classname<\/em>( );<\/p>\n

 <\/p>\n

Here, class-var <\/em>is a variable of the class type being created. The classname <\/em>is the name of the class that is being instantiated. The class name followed by parentheses specifies the constructor <\/em>for the class. A constructor defines what occurs when an object of a class is created. However, if no explicit constructor is specified, then Java will automatically supply a default constructor. This is the case with Box<\/strong>. It is important to understand that new <\/strong>allocates memory for an object during run time. The advantage of this approach is that your program can create as many objects as it needs during the execution of your program.\u00a0 A class creates a new data type that can be used to create objects. That is, a class creates a logical framework that defines the relationship between its members. When you declare an object of a class, you are creating an instance of that class. Thus, a class is a logical construct. An object has physical reality and an object occupies space in memory.<\/p>\n

<\/a>Assigning Object Reference Variables<\/h3>\n

For example:<\/p>\n

 <\/p>\n

Box b1 = new Box();<\/p>\n

Box b2 = b1;<\/p>\n

 <\/p>\n

after this executes, b1 <\/strong>and b2 <\/strong>will both refer to the same <\/em>object. The assignment of b1 <\/strong>to b2 <\/strong>did not allocate any memory or copy any part of the original object. It simply makes b2 <\/strong>refer to the same object as does b1<\/strong>. Thus, any changes made to the object through b2 <\/strong>will affect the object to which b1 <\/strong>is referring, since they are the same object. \u00a0Look at the other example:<\/p>\n

 <\/p>\n

Box b1 = new Box();<\/p>\n

Box b2 = b1;<\/p>\n

\/\/ …<\/p>\n

b1 = null;<\/p>\n

 <\/p>\n

Here, b1 <\/strong>has been set to null<\/strong>, but b2 <\/strong>still points to the original object. When you assign one object reference variable to another object reference variable, you are not creating a copy of the object, you are only making a copy of the reference.<\/em><\/p>\n

 <\/p>\n

<\/a>Introducing Methods<\/strong><\/h2>\n

 <\/p>\n

Classes usually consist of two things: instance variables and methods. This is the general form of a method:<\/p>\n

 <\/p>\n

type name<\/em>(parameter<\/em>–list<\/em>) {<\/p>\n

\/\/ body of method<\/p>\n

}<\/p>\n

 <\/p>\n

Here, type <\/em>specifies the type of data returned by the method. This can be any valid type, including class types that you create. If the method does not return a value, its return type must be void<\/strong>. The name of the method is specified by name. <\/em>This can be any legal identifier other than those already used by other items. The parameter-list <\/em>is a sequence of type and identifier pairs separated by commas. Parameters are essentially variables that receive the value of the arguments <\/em>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 <\/strong>return a value to the calling method using the following form of the return <\/strong>statement:<\/p>\n

 <\/p>\n

return value<\/em>;<\/p>\n

 <\/p>\n

Here, value <\/em>is the value returned.<\/p>\n

<\/a>Adding a Method to the Box Class<\/h3>\n

 <\/p>\n

Although it is perfectly fine to create a class that contains only data. Most of the time you will use methods to access the instance variables defined by the class. In addition to defining methods that provide access to data, you can also define methods that are used internally by the class itself. Let\u2019s begin by adding a method to the Box <\/strong>class. since the volume of a box is dependent upon the size of the box, it makes sense to have the Box <\/strong>class compute it. To do this, you must add a method to Box<\/strong>, as shown here:<\/p>\n

 <\/p>\n

\/\/ This program includes a method inside the box class.<\/p>\n

class Box {<\/p>\n

double width;<\/p>\n

double height;<\/p>\n

double depth;<\/p>\n

\/\/ display volume of a box<\/p>\n

void volume() {<\/p>\n

System.out.print(“Volume is “);<\/p>\n

System.out.println(width * height * depth);<\/p>\n

}<\/p>\n

}<\/p>\n

class BoxDemo3 {<\/p>\n

public static void main(String args[]) {<\/p>\n

Box mybox1 = new Box();<\/p>\n

Box mybox2 = new Box();<\/p>\n

\/\/ assign values to mybox1’s instance variables<\/p>\n

mybox1.width = 10;<\/p>\n

mybox1.height = 20;<\/p>\n

mybox1.depth = 15;<\/p>\n

\/* assign different values to mybox2’s<\/p>\n

instance variables *\/<\/p>\n

mybox2.width = 3;<\/p>\n

mybox2.height = 6;<\/p>\n

mybox2.depth = 9;<\/p>\n

\/\/ display volume of first box<\/p>\n

mybox1.volume();<\/p>\n

\/\/ display volume of second box<\/p>\n

mybox2.volume();<\/p>\n

}<\/p>\n

}<\/p>\n

 <\/p>\n

This program generates the following output, which is the same as the previous version.<\/p>\n

Volume is 3000.0<\/p>\n

Volume is 162.0<\/p>\n

 <\/p>\n

Look closely at the following two lines of code:<\/p>\n

mybox1.volume();<\/p>\n

mybox2.volume();<\/p>\n

 <\/p>\n

The first line here invokes the volume( ) <\/strong>method on mybox1<\/strong>. That is, it calls volume( ) <\/strong>relative to the mybox1 <\/strong>object, using the object\u2019s name followed by the dot operator. Thus, the call to mybox1.volume( ) <\/strong>displays the volume of the box defined by mybox1<\/strong>, and the call to mybox2.volume( ) <\/strong>displays the volume of the box defined by mybox2<\/strong>. Each time volume( ) <\/strong>is invoked, it displays the volume for the specified box. After the statements inside volume( ) <\/strong>have executed, control is returned to the calling routine, and execution resumes with the line of code following the call. There is something very important to notice inside the volume( ) <\/strong>method: the instance variables width<\/strong>, height<\/strong>, and depth <\/strong>are referred to directly, without preceding them with an object name or the dot operator. When a method uses an instance variable that is defined by its class, it does so directly, without explicit reference to an object and without use of the dot operator.\u00a0 A method is always invoked relative to some object of its class. Once this invocation has occurred, the object is known. This means that width<\/strong>, height<\/strong>, and depth <\/strong>inside volume( ) <\/strong>implicitly refer to the copies of those variables found in the object that invokes volume( )<\/strong>.<\/p>\n

<\/a>Returning a Value<\/h3>\n

 <\/p>\n

While the implementation of volume( ) <\/strong>does move the computation of a box\u2019s volume inside the Box <\/strong>class where it belongs, it is not the best way to do it. A better way to implement volume( ) <\/strong>is to have it compute the volume of the box and return the result to the caller. The following example does just that:<\/p>\n

\/\/ Now, volume() returns the volume of a box.<\/p>\n

class Box {<\/p>\n

double width;<\/p>\n

double height;<\/p>\n

double depth;<\/p>\n

\/\/ compute and return volume<\/p>\n

double volume() {<\/p>\n

return width * height * depth;<\/p>\n

}<\/p>\n

}<\/p>\n

class BoxDemo4 {<\/p>\n

public static void main(String args[]) {<\/p>\n

Box mybox1 = new Box();<\/p>\n

Box mybox2 = new Box();<\/p>\n

double vol;<\/p>\n

\/\/ assign values to mybox1’s instance variables<\/p>\n

mybox1.width = 10;<\/p>\n

mybox1.height = 20;<\/p>\n

mybox1.depth = 15;<\/p>\n

\/* assign different values to mybox2’s<\/p>\n

instance variables *\/<\/p>\n

mybox2.width = 3;<\/p>\n

mybox2.height = 6;<\/p>\n

mybox2.depth = 9;<\/p>\n

\/\/ get volume of first box<\/p>\n

vol = mybox1.volume();<\/p>\n

System.out.println(“Volume is ” + vol);<\/p>\n

\/\/ get volume of second box<\/p>\n

vol = mybox2.volume();<\/p>\n

System.out.println(“Volume is ” + vol);<\/p>\n

}<\/p>\n

}<\/p>\n

 <\/p>\n

As you can see, when volume( ) <\/strong>is called, it is put on the right side of an assignment statement. On the left is a variable, in this case vol<\/strong>, that will receive the value returned by volume( )<\/strong>. Thus, after<\/p>\n

 <\/p>\n

vol = mybox1.volume();<\/p>\n

 <\/p>\n

executes, the value of mybox1.volume( ) <\/strong>is 3,000 and this value then is stored in vol<\/strong>. There are two important things to understand about returning values:<\/p>\n

 <\/p>\n