internet computing

Internet Computing

Module II

Syllabus

Creating & Using classes in Java – Methods and Classes – Inheritance – Super Class – Method Overriding – Packages and Interfaces - Implementing Interfaces – Exception Handling – Exception types – Threads – Multithreaded programs, thread Priorities and Thread Synchronization

Internet Computing GEC Idukki

Classes• The class is at the core of Java. • It is the logical construct upon which the entire Java

language is built because it defines the shape and nature of an object.

• 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.

• A class 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.


Classes• 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}}


•The data, or variables, defined within a class are called instance variables.

•The code is contained within methods.

•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.

Classesclass Box {double width;double height;double depth;}

• a class defines a new type of data• the new data type is called Box• A class declaration only creates a template; it

does not create an actual object. Box mybox = new Box();



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 variablesmybox.width = 10;mybox.height = 20;mybox.depth = 15;// compute volume of boxvol = mybox.width * mybox.height * mybox.depth;System.out.println("Volume is " + vol);}}

Classes• 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.• 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. This is done 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 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.



Classes

1. indicates that it does not yet point to an actual object.

2. mybox simply holds the memory address of the actual Box object

Classes• new allocates memory for an object during run

time.• The advantage of this approach is that your

program can create as many or as few objects as it needs during the execution of your program.

• Since memory is finite, it is possible that new will not be able to allocate memory for an object because insufficient memory exists.

• If this happens, a run-time exception will occur.


ClassesBox b1 = new Box();Box b2 = b1;

• After this fragment executes,b1 andb2 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.


Classes - Methods• Add method volume() to the BOX class• Modify volume() so that it returns the volume

back to the caller• Define a method setDim() which will take 3

parameters which are used as the values for setting the instance variables.


Constructors• Java allows objects to initialize themselves when they are created.

• This automatic initialization is performed through the use of a constructor. 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. This is because the implicit return type of a class’ constructor is the class type itself.

• Create Constructor for Box classInternet Computing GEC Idukki

Constructors• Parameterized Constructors allow different

objects to initialize themselves differently when they are created

• Create a parameterized constructor for Box class


Use of this• Sometimes a method will need to refer to the

object that invoked it. • To allow this, Java defines the this keyword. this

can be used inside any method to refer to the current object.

• this is always a reference to the object on which the method was invoked.

• You can use this anywhere a reference to an object of the current class’ type is permitted.


Use of thisBox(double w, double h, double d) {this.width = w;this.height = h;this.depth = d;}


Use of this• It is illegal in Java to declare two local variables

with the same name inside the same or enclosing scopes.

• But we can have local variables, including formal parameters to methods, which overlap with the names of the class’ instance variables.

• However, when a local variable has the same name as an instance variable, the local variable hides the instance variable.


Use of this• While it is usually easier to simply use different

names, there is another way around this situation. • Because this lets you refer directly to the object, you

can use it to resolve any name space collisions that might occur between instance variables and local variables.

Box(double width, double height, double depth) {this.width = width;this.height = height;this.depth = depth;}


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 de-allocation

automatically.• The technique that accomplishes this is called garbage

collection. • 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.

• Different Java run-time implementations will take varying approaches to garbage collection


Garbage Collection• Sometimes an object will need to perform some

action when it is destroyed. • For example, if an object is holding some non-

Java resource such as a file handle, then you might want to make sure these resources are freed before an object is destroyed.

• To handle such situations, Java provides a mechanism called finalization.

• By using finalization, you can define specific actions that will occur when an object is just about to be reclaimed by the garbage collector.


Garbage Collection• To add a finalizer to a class, you simply define the

finalize( ) method. • The Java run time calls that method whenever it is

about to recycle an object of that class. • Inside the finalize( ) method, you will specify those

actions that must be performed before an object is destroyed.

• The garbage collector runs periodically, checking for objects that are no longer referenced by any running state or indirectly through other referenced objects.

• Right before an asset is freed, the Java run time calls the finalize( ) method on the object.


Garbage Collection• The finalize( ) method has this general form:

protected void finalize( ){// finalization code here}

• It is important to understand that finalize() is only called just prior to garbage collection.

• It is not called when an object goes out-of-scope, for example.

• This means that you cannot know when—or even if—finalize() will be executed.

• Therefore, your program should provide other means of releasing system resources, etc., used by the object.

• It must not rely on finalize( ) for normal program operation.


Overloading Methods• In Java it is possible to define two or more

methods within the same class that share the same name, as long as their parameter declarations are different.

• When this is the case, the methods are said to be overloaded, and the process is referred to as method overloading.

• Method overloading is one of the ways that Java supports polymorphism.


Overloading Methods• When an overloaded method is invoked, Java

uses the type and/or number of arguments as its guide to determine which version of the overloaded method to actually call.

• Thus, overloaded methods must differ in the type and/or number of their parameters.

• While overloaded methods may have different return types, the return type alone is insufficient to distinguish two versions of a method.


Overloading Methods• When Java encounters a call to an overloaded

method, it simply executes the version of the method whose parameters match the arguments used in the call.

•


internet computing

Documents