Module 2  The data, or variables, defined within a class are called instance variables.

 The code is contained within methods.

Introducing Classes
 Collectively, the methods and variables defined within a class are called members of
 The class is at the core of Java. the class.
 It is the logical construct upon which the entire Java language is built because it  Variables defined within a class are called instance variables because each instance of
defines the shape and nature of an object. 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.
Class Fundamentals
 Class defines a new data type. Once defined, this new type can be used to create A Simple Class
objects of that type.  Here is a class called Box that defines three instance variables: width, height, and
 Thus, a class is a template for an object, and an object is an instance of a class. depth.
Because an object is an instance of a class, you will often see the two words object class Box {
and instance used interchangeably. double width;
double height;
The General Form of a Class double depth;
 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.
 A class is declared by use of the class keyword  As stated, a class defines a new type of data.
 In this case, the new data type is called Box.
class classname {  You will use this name to declare objects of type Box.
type instance-variable1;  It is important to remember that a class declaration only creates a template; it does not
type instance-variable2; create an actual object
// ...
type instance-variableN; Box mybox = new Box(); // create a Box object called mybox
type methodname1(parameter-list) {  After this statement executes, mybox will be an instance of Box.
// body of method  Thus, it will have “physical” reality.
}  Thus, every Box object will contain its own copies of the instance variables width,
type methodnameN(parameter-list) { height, and depth.
// body of method  To 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;
class Box { Box mybox = new Box();
double width;  This statement combines the two steps just described. It can be rewritten like this to
double height; show each step more clearly:
double depth; Box mybox; // declare reference to object
} mybox = new Box(); // allocate a Box object
// This class declares an object of type Box.  The first line declares mybox as a reference to an object of type Box.
class BoxDemo {  After this line executes, mybox contains the value null, which indicates that it does
public static void main(String args[]) { not yet point to an actual object.
Box mybox = new Box();  Any attempt to use mybox at this point will result in a compile-time error. The next
double vol; line allocates an actual object and assigns a reference to it to mybox.
// assign values to mybox's instance variables  After the second line executes, you can use mybox as if it were a Box object. But in
mybox.width = 10; reality, mybox simply holds the memory address of the actual Box object.
mybox.height = 20;
mybox.depth = 15;
// compute volume of box
vol = mybox.width * mybox.height * mybox.depth;
System.out.println("Volume is " + vol);
}
}

Declaring Objects
 Here, class-var is a variable of the class type being created. The classname is the
 When you create a class, you are creating a new data type.
name of the class that is being instantiated.
 However, obtaining objects of a class is a two-step process.
 The class name followed by parentheses specifies the constructor for the class.
 First, you must declare a variable of the class type. This variable does not define an
 A constructor defines what occurs when an object of a class is created.
object. Instead, it is simply a variable that can refer to an object.
 Constructors are an important part of all classes and have many significant attributes.
 Second, you must acquire an actual, physical copy of the object and assign it to that
 It is important to understand that new allocates memory for an object during run time.
variable. You can do this using the new operator.
 The advantage of this approach is that your program can create as many or as few
 The new operator dynamically allocates (that is, allocates at run time) memory for an
objects as it needs during the execution of your program.
object and returns a reference to it.
 However, since memory is finite, it is possible that new will not be able to allocate
 This reference is, more or less, the address in memory of the object allocated by new.
memory for an object because insufficient memory exists.
This reference is then stored in the variable.
 If this happens, a run-time exception will occur.
 Thus, in Java, all class objects must be dynamically allocated.
 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 Introducing methods
members. When you declare an object of a class, you are creating an instance of that
class. This is the general form of a method:
 Thus, a class is a logical construct. An object has physical reality. type name(parameter-list) {
// body of method
Assigning Object Reference Variables }
Object reference variables act differently when an assignment takes place.  Here, type specifies the type of data returned by the method. This can be any valid
Box b1 = new Box(); type, including class types that you create.
Box b2 = b1;  If the method does not return a value, its return type must be void.
 The 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.
 The 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:
 After this fragment executes, b1 and b2 will both refer to the same object.
return value;
 The assignment of b1 to b2 did not allocate any memory or copy any part of the
 Here, value is the value returned.
original object.
 It simply makes b2 refer to the same object as does b1.
Adding a Method to the Box Class
 Thus, any changes made to the object through b2 will affect the object to which b1
class Box {
is referring, since they are the same object.
double width;
 Although b1 and b2 both refer to the same object, they are not linked in any other
double height;
way.
double depth;
Box b1 = new Box(); Box b2 = b1;
// display volume of a box
// ...
void volume() {
b1 = null;
System.out.print("Volume is ");
System.out.println(width * height * depth);
Here, b1 has been set to null, but b2 still points to the original object.
}
}
class BoxDemo3 {
public static void main(String args[]) {
 Box mybox1 = new Box(); double height;
// assign values to mybox1's instance variables double depth;
mybox1.width = 10; // compute and return volume
mybox1.height = 20; double volume() {
mybox1.depth = 15; return width * height * depth;
// display volume of first box }
mybox1.volume(); }
} class BoxDemo4 {
} public static void main(String args[]) {
This program generates the following output, which is the same as the previous version. Box mybox1 = new Box();
Volume is 3000.0 double vol;
Volume is 162.0 // assign values to mybox1's instance variables
mybox1.width = 10;
Look closely at the following two lines of code: mybox1.height = 20;
mybox1.volume(); mybox1.depth = 15;
 The first line here invokes the volume( ) method on mybox1. // get volume of first box
 That is, it calls volume( ) relative to the mybox1 object, using the object’s name vol = mybox1.volume();
followed by the dot operator. System.out.println("Volume is " + vol);
 Thus, the call to mybox1.volume( ) displays the volume of the box defined by }
mybox1, }
 There is something very important to notice inside the volume( ) method: the instance  As you can see, when volume( ) is called, it is put on the right side of an assignment
variables width, height, and depth are referred to directly, without preceding them statement.
with an object name or the dot operator.  On the left is a variable, in this case vol, that will receive the value returned by
 When a method uses an instance variable that is defined by its class, it does so volume( ).
directly, without explicit reference to an object and without use of the dot operator.  Thus, after vol = mybox1.volume(); executes, the value of mybox1.volume( ) is
 This is easy to understand if you think about it. Amethod is always invoked relative to 3,000 and this value then is stored in vol.
some object of its class. Once this invocation has occurred, the object is known.
There are two important things to understand about returning values:
Returning a Value  The type of data returned by a method must be compatible with the return type
 While the implementation of volume( ) does move the computation of a box’s volume specified by the method. For example, if the return type of some method is boolean,
inside the Box class where it belongs, it is not the best way to do it. you could not return an integer.
class Box {  The variable receiving the value returned by a method (such as vol, in this case) must
double width; also be compatible with the return type specified for the method.
Adding a Method That Takes Parameters  An argument is a value that is passed to a method when it is Invoked.
 While some methods don’t need parameters, most do. Parameters allow a method to  For example, square(100) passes 100 as an argument. Inside square( ), the parameter
be generalized. i receives that value.
 That is, a parameterized method can operate on a variety of data and/or be used in a  Thus, a better approach to setting the dimensions of a box is to create a method that
number of slightly different situations takes the dimensions of a box in its parameters and sets each instance variable
appropriately.
int square()  This concept is implemented by the following program:
{ // This program uses a parameterized method.
return 10 * 10; class Box {
} double width;
 While this method does, indeed, return the value of 10 squared, its use is very limited. double height;
 However, if you modify the method so that it takes a parameter, as shown next, then double depth;
you can make square( ) much more useful. // compute and return volume
int square(int i) double volume() {
{ return width * height * depth;
return i * i; }
} // sets dimensions of box
 Now, square( ) will return the square of whatever value it is called with. That is, void setDim(double w, double h, double d) {
square( ) is now a general-purpose method that can compute the square of any integer width = w;
value, rather than just 10. height = h;
Here is an example: depth = d;
int x, y; }
x = square(5); // x equals 25 }
x = square(9); // x equals 81 class BoxDemo5 {
y = 2; public static void main(String args[]) {
x = square(y); // x equals 4 Box mybox1 = new Box();
 In the first call to square( ), the value 5 will be passed into parameter i. Box mybox2 = new Box();
 In the second call, I will receive the value 9. double vol;
 The third invocation passes the value of y, which is 2 in this example. // initialize each box
 As these examples show, square( ) is able to return the square of whatever data it is mybox1.setDim(10, 20, 15);
passed mybox2.setDim(3, 6, 9);
 A parameter is a variable defined by a method that receives a value when the method // get volume of first box
is called. For example, in square( ), i is a parameter. vol = mybox1.volume();
 System.out.println("Volume is " + vol); double depth;
// get volume of second box // This is the constructor for Box.
vol = mybox2.volume(); Box() {
System.out.println("Volume is " + vol); System.out.println("Constructing Box");
} width = 10;
} height = 10;
 As you can see, the setDim( ) method is used to set the dimensions of each box. For depth = 10;
example, when mybox1.setDim(10, 20, 15); is executed, 10 is copied into parameter }
w, 20 is copied into h, and 15 is copied into d. // compute and return volume
 Inside setDim( ) the values of w, h, and d are then assigned to width, height, and double volume() {
depth, respectively. return width * height * depth;
}

Constructors }
class BoxDemo6 {
 It can be tedious to initialize all of the variables in a class each time an instance is
public static void main(String args[]) {
created.
// declare, allocate, and initialize Box objects
 Even when you add convenience functions like setDim( ), it would be simpler and
Box mybox1 = new Box();
more concise to have all of the setup done at the time the object is first created.
Box mybox2 = new Box();
 Because the requirement for initialization is so common, Java allows objects to
double vol;
initialize themselves when they are created.
// get volume of first box
 This automatic initialization is performed through the use of a constructor.
vol = mybox1.volume();
 A constructor initializes an object immediately upon creation.
System.out.println("Volume is " + vol);
 It has the same name as the class in which it resides and is syntactically similar to a
// get volume of second box
method.
vol = mybox2.volume();
 Once defined, the constructor is automatically called immediately after the object is
System.out.println("Volume is " + vol);
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.
When this program is run, it generates the following results:
 It is the constructor’s job to initialize the internal state of an object so that the code
Constructing Box
creating an instance will have a fully initialized, usable object immediately.
Constructing Box
Volume is 1000.0
class Box {
Volume is 1000.0
double width;
double height;
 class-var = new classname( ); Box mybox1 = new Box(10, 20, 15);
 Now you can understand why the parentheses are needed after the class name. What Box mybox2 = new Box(3, 6, 9);
is actually happening is that the constructor for the class is being called. Thus, in the double vol;
line // get volume of first box
Box mybox1 = new Box(); vol = mybox1.volume();
 new Box( ) is calling the Box( ) constructor new . System.out.println("Volume is " + vol);
 When you do not explicitly define a constructor for a class, then Java creates a default // get volume of second box
constructor for the class vol = mybox2.volume();
System.out.println("Volume is " + vol);
Parameterized Constructors }
}
 While the Box( ) constructor in the preceding example does initialize a Box object, it The output from this program is shown here:
is not very useful—all boxes have the same dimensions. Volume is 3000.0
 What is needed is a way to construct Box objects of various dimensions. Volume is 162.0

 The easy solution is to add parameters to the constructor

class Box { The this keyword
double width;  Sometimes a method will need to refer to the object that invoked it.
double height;  To allow this, Java defines the this keyword. this can be used inside any method to
double depth; refer to the current object
// This is the constructor for Box.
Box(double w, double h, double d) { Box(double w, double h, double d) {
width = w; this.width = w;
height = h; this.height = h;
depth = d; this.depth = d;
} }
// compute and return volume Uses of this:
double volume() {  To overcome shadowing or instance variable hiding.
return width * height * depth;  To call an overload constructor
}
} Instance Variable Hiding
class BoxDemo7 {  It is illegal in Java to declare two local variables with the same name inside the same
public static void main(String args[]) { or enclosing scopes.
// declare, allocate, and initialize Box objects
  Interestingly, you can have local variables, including formal parameters to methods,  By using finalization, you can define specific actions that will occur when an object is
which overlap with the names of the class’ instance variables. just about to be reclaimed by the garbage collector.
 However, when a local variable has the same name as an instance variable, the local The finalize( ) method has this general form:
variable hides the instance variable. protected void finalize( )
// Use this to resolve name-space collisions. {
Box(double width, double height, double depth) { // finalization code here
this.width = width; }
this.height = height;  Here, the keyword protected is a specifier that prevents access to finalize( ) by code
this.depth = depth; defined outside its class.
}  It is important to understand that finalize( ) is only called just prior to garbage
NOTE: The use of this in such a context can sometimes be confusing, and some collection.
programmers are careful not to use local variables and formal parameter names that hide  It is not called when an object goes out-of-scope, for example. This means that you
instance variables. cannot know when—or even if—finalize( ) will be executed.
 Therefore, your program should provide other means of releasing system resources,
Garbage Collection etc., used by the object.
 Since objects are dynamically allocated by using the new operator, you might be  It must not rely on finalize( ) for normal program operation.
wondering how such objects are destroyed and their memory released for later
reallocation. A Stack Class
 Java takes a different approach; it handles deallocation for you automatically. class Stack {
 The technique that accomplishes this is called garbage collection. int stck[] = new int[10];
 It works like this: when no references to an object exist, that object is assumed to be int tos;
no longer needed, and the memory occupied by the object can be reclaimed. // Initialize top-of-stack
 There is no explicit need to destroy objects as in C++. Stack() {
 Garbage collection only occurs sporadically (if at all) during the execution of your top = -1;
program. }
 It will not occur simply because one or more objects exist that are no longer used. // Push an item onto the stack
void push(int item) {
The finalize( ) Method if(top==9)

 Sometimes an object will need to perform some action when it is destroyed. For System.out.println("Stack is full.");

example, if an object is holding some non-Java resource such as a file handle or else
character font, then you might want to make sure these resources are freed before an stck[++top] = item;
object is destroyed. }
 To handle such situations, Java provides a mechanism called finalization. // Pop an item from the stack
 int pop() { 2
if(top < 0) { 1
System.out.println("Stack underflow."); 0
return 0; Stack in mystack2:
} 19
else 18
return stck[top--]; 17
} 16
} 15
class TestStack { 14
public static void main(String args[]) { 13
Stack mystack1 = new Stack(); 12
Stack mystack2 = new Stack(); 11
// push some numbers onto the stack 10
for(int i=0; i<10; i++) mystack1.push(i);
for(int i=10; i<20; i++) mystack2.push(i); Overloading Methods
// pop those numbers off the stack  In Java it is possible to define two or more methods within the same class that share
System.out.println("Stack in mystack1:"); the same name, as long as their parameter declarations are different.
for(int i=0; i<10; i++)  When this is the case, the methods are said to be overloaded, and the process is
System.out.println(mystack1.pop()); referred to as method overloading.
System.out.println("Stack in mystack2:");  Method overloading is one of the ways that Java supports polymorphism.
for(int i=0; i<10; i++)  When an overloaded method is invoked, Java uses the type and/or number of
System.out.println(mystack2.pop()); 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.
This program generates the following output:
 While overloaded methods may have different return types, the return type alone is
Stack in mystack1:
insufficient to distinguish two versions of a method.
9
8
class OverloadDemo {
7
void test() {
6
System.out.println("No parameters");
5
}
4
// Overload test for one integer parameter.
3
 void test(int a) {  However, this match need not always be exact. In some cases, Java’s automatic type
System.out.println("a: " + a); conversions can play a role in overload resolution.
}
// Overload test for two integer parameters. For example, consider the following program:
void test(int a, int b) { // Automatic type conversions apply to overloading.
System.out.println("a and b: " + a + " " + b); class OverloadDemo {
} void test() {
// overload test for a double parameter System.out.println("No parameters");
double test(double a) { }
System.out.println("double a: " + a); // Overload test for two integer parameters.
return a*a; void test(int a, int b) {
} System.out.println("a and b: " + a + " " + b);
} }
class Overload { // overload test for a double parameter
public static void main(String args[]) { void test(double a) {
OverloadDemo ob = new OverloadDemo(); System.out.println("Inside test(double) a: " + a);
double result; }
// call all versions of test() }
ob.test(); class Overload {
ob.test(10); public static void main(String args[]) {
ob.test(10, 20); OverloadDemo ob = new OverloadDemo();
result = ob.test(123.25); int i = 88;
System.out.println("Result of ob.test(123.25): " + result); ob.test();
} ob.test(10, 20);
} ob.test(i); // this will invoke test(double)
This program generates the following output: ob.test(123.2); // this will invoke test(double)
No parameters }
a: 10 }
a and b: 10 20 This program generates the following output:
double a: 123.25 No parameters
Result of ob.test(123.25): 15190.5625 a and b: 10 20
Inside test(double) a: 88
 When an overloaded method is called, Java looks for a match between the arguments Inside test(double) a: 123.2
used to call the method and the method’s parameters.
  When test( ) is called with an integer argument inside Overload, no matching method // constructor used when no dimensions specified
is found. Box() {
 However, Java can automatically convert an integer into a double, and this width = -1; // use -1 to indicate
conversion can be used to resolve the call. height = -1; // an uninitialized
 Therefore, after test(int) is not found, Java elevates i to double and then calls depth = -1; // box
test(double). }
 Of course, if test(int) had been defined, it would have been called instead. Java will // constructor used when cube is created
employ its automatic type conversions only if no exact match is found. Box(double len) {
 Method overloading supports polymorphism because it is one way that Java width = height = depth = len;
implements the “one interface, multiple methods” paradigm. }

 When you overload a method, each version of that method can perform any activity // compute and return volume
you desire. double volume() {

 There is no rule stating that overloaded methods must relate to one another. return width * height * depth;

 However, from a stylistic point of view, method overloading implies a relationship. }

Thus, while you can use the same name to overload unrelated methods, you should }

not. class OverloadCons {

public static void main(String args[]) {

Overloading Constructors // create boxes using the various constructors

 In addition to overloading normal methods, you can also overload constructor Box mybox1 = new Box(10, 20, 15);

methods. In fact, for most real-world classes that you create, overloaded constructors Box mybox2 = new Box();

will be the norm, not the exception. Box mycube = new Box(7);

 To understand why, let’s return to the Box class developed in the preceding chapter. double vol;

Following is the latest version of Box: vol = mybox1.volume();

class Box { System.out.println("Volume of mybox1 is " + vol);

double width; // get volume of second box

double height; vol = mybox2.volume();

double depth; System.out.println("Volume of mybox2 is " + vol);

// constructor used when all dimensions specified // get volume of cube

Box(double w, double h, double d) { vol = mycube.volume();

width = w; System.out.println("Volume of mycube is " + vol);

height = h; }

depth = d; }

} The output produced by this program is shown here:

Volume of mybox1 is 3000.0
Volume of mybox2 is -1.0  As you can see, the equals( ) method inside Test compares two objects for equality
Volume of mycube is 343.0 and returns the result.
 That is, it compares the invoking object with the one that it is passed.
Using Objects as Parameters  If they contain the same values, then the method returns true. Otherwise, it returns
 So far, we have only been using simple types as parameters to methods. However, it is false. Notice that the parameter o in equals( ) specifies Test as its type.
both correct and common to pass objects to methods.  Although Test is a class type created by the program, it is used in just the same way
 For example, consider the following short program: as Java’s built-in types.
// Objects may be passed to methods.  One of the most common uses of object parameters involves constructors. Frequently,
class Test { you will want to construct a new object so that it is initially the same as some existing
int a, b; object.
Test(int i, int j) {  To do this, you must define a constructor that takes an object of its class as a
a = i; parameter
b = j;
} A Closer Look at Argument Passing
// return true if o is equal to the invoking object  In general, there are two ways that a computer language can pass an argument to a
boolean equals(Test o) { subroutine.
if(o.a == a && o.b == b) return true;  The first way is call-by-value. This approach copies the value of an argument into the
else return false; formal parameter of the subroutine. Therefore, changes made to the parameter of the
} subroutine have no effect on the argument.
}  The second way an argument can be passed is call-by-reference. In this approach, a
class PassOb { reference to an argument (not the value of the argument) is passed to the parameter.
public static void main(String args[]) {  Inside the subroutine, this reference is used to access the actual argument specified in
Test ob1 = new Test(100, 22); the call. This means that changes made to the parameter will affect the argument used
Test ob2 = new Test(100, 22); to call the subroutine.
Test ob3 = new Test(-1, -1);  As you will see, Java uses both approaches, depending upon what is passed.
System.out.println("ob1 == ob2: " + ob1.equals(ob2));  In Java, when you pass a primitive type to a method, it is passed by value. Thus, what
System.out.println("ob1 == ob3: " + ob1.equals(ob3)); occurs to the parameter that receives the argument has no effect outside the method.
} For example, consider the following program:
} // Primitive types are passed by value.
This program generates the following output: class Test {
ob1 == ob2: true void meth(int i, int j) {
ob1 == ob3: false i *= 2;
j /= 2;
 } o.a *= 2;
} o.b /= 2;
class CallByValue { }
public static void main(String args[]) { }
Test ob = new Test(); class CallByRef {
int a = 15, b = 20; public static void main(String args[]) {
System.out.println("a and b before call: " + Test ob = new Test(15, 20);
a + " " + b); System.out.println("ob.a and ob.b before call: " +
ob.meth(a, b); ob.a + " " + ob.b);
System.out.println("a and b after call: " + ob.meth(ob);
a + " " + b); System.out.println("ob.a and ob.b after call: " +
} ob.a + " " + ob.b);
} }
The output from this program is shown here: }
a and b before call: 15 20 This program generates the following output:
a and b after call: 15 20 ob.a and ob.b before call: 15 20
ob.a and ob.b after call: 30 10
 When you pass an object to a method, the situation changes dramatically, because
objects are passed by what is effectively call-by-reference. Returning Objects
 Thus, when you pass this reference to a method, the parameter that receives it will  A method can return any type of data, including class types that you create. For
refer to the same object as that referred to by the argument. example, in the following program, the incrByTen( ) method returns an object in
 This effectively means that objects are passed to methods by use of call-by-reference. which the value of a is ten greater than it is in the invoking object.
Changes to the object inside the method do affect the object used as an argument. // Returning an object.
 For example, consider the following program: class Test {
// Objects are passed by reference. int a;
class Test { Test(int i) {
int a, b; a = i;
Test(int i, int j) { }
a = i; Test incrByTen() {
b = j; Test temp = new Test(a+10);
} return temp;
// pass an object }
void meth(Test o) { }
class RetOb {
 public static void main(String args[]) { }
Test ob1 = new Test(2); class Recursion {
Test ob2; public static void main(String args[]) {
ob2 = ob1.incrByTen(); Factorial f = new Factorial();
System.out.println("ob1.a: " + ob1.a); System.out.println("Factorial of 3 is " + f.fact(3));
System.out.println("ob2.a: " + ob2.a); System.out.println("Factorial of 4 is " + f.fact(4));
ob2 = ob2.incrByTen(); System.out.println("Factorial of 5 is " + f.fact(5));
System.out.println("ob2.a after second increase: " + ob2.a); }
} }
} The output from this program is shown here:
The output generated by this program is shown here: Factorial of 3 is 6
ob1.a: 2 Factorial of 4 is 24
ob2.a: 12 Factorial of 5 is 120
ob2.a after second increase: 22  When a method calls itself, new local variables and parameters are allocated storage
on the stack, and the method code is executed with these new variables from the start.
Recursion  As each recursive call returns, the old local variables and parameters are removed
 Java supports recursion. Recursion is the process of defining something in terms of from the stack, and execution resumes at the point of the call inside the method.
itself. As it relates to Java programming, recursion is the attribute that allows a  Recursive methods could be said to “telescope” out and back.
method to call itself.  Recursive versions of many routines may execute a bit more slowly than the iterative
 A method that calls itself is said to be recursive. equivalent because of the added overhead of the additional function calls.
 The classic example of recursion is the computation of the factorial of a number. The  Many recursive calls to a method could cause a stack overrun. Because storage for
factorial of a number N is the product of all the whole numbers between 1 and N. parameters and local variables is on the stack and each new call creates a new copy of
 For example, 3 factorial is 1 × 2 × 3, or 6. Here is how a factorial can be computed by these variables, it is possible that the stack could be exhausted.
use of a recursive method:  If this occurs, the Java run-time system will cause an exception.
// A simple example of recursion.
class Factorial { The main advantage to recursive methods is that they can be used to create clearer and
// this is a recursive method simpler versions of several algorithms than can their iterative relatives.
int fact(int n) {
int result; Here is one more example of recursion. The recursive method printArray( ) prints the first i
if(n==1) return 1; elements in the array values.
result = fact(n-1) * n; // Another example that uses recursion.
return result; class RecTest {
} int values[];
 RecTest(int i) {  Through encapsulation, you can control what parts of a program can access the
values = new int[i]; members of a class.
}  By controlling access, you can prevent misuse. For example, allowing access to data
// display array -- recursively only through a welldefined set of methods, you can prevent the misuse of that data.
void printArray(int i) {  Thus, when correctly implemented, a class creates a “black box” which may be used,
if(i==0) return; but the inner workings of which are not open to tampering
else printArray(i-1);  Java’s access specifiers are public, private, and protected.
System.out.println("[" + (i-1) + "] " + values[i-1]);  Java also defines a default access level. protected applies only when inheritance is
} involved When a member of a class is modified by the public specifier, then that
} member can be accessed by any other code.
class Recursion2 {  When a member of a class is specified as private, then that member can only be
public static void main(String args[]) { accessed by other members of its class.
RecTest ob = new RecTest(10);  Now you can understand why main( ) has always been preceded by the public
int i; specifier. It is called by code that is outside the program—that is, by the Java run-time
for(i=0; i<10; i++) ob.values[i] = i; system.
ob.printArray(10);  When no access specifier is used, then by default the member of a class is public
} within its own package, but cannot be accessed outside of its package.
}  An access specifier precedes the rest of a member’s type specification. That is, it must
This program generates the following output: begin a member’s declaration statement.
[0] 0  Here is an example:
[1] 1 public int i;
[2] 2 private double j;
[3] 3 private int myMethod(int a, char b) { // ...
[4] 4 class Test {
[5] 5 int a; // default access
[6] 6 public int b; // public access
[7] 7 private int c; // private access
[8] 8 // methods to access c
[9] 9 void setc(int i) { // set c's value
c = i;
Introducing Access Control }
 encapsulation provides another important attribute: access control. int getc() { // get c's value
return c;
 }  When a member is declared static, it can be accessed before any objects of its
} class are created, and without reference to any object.
class AccessTest {  You can declare both methods and variables to be static.
public static void main(String args[]) {  The most common example of a static member is main( ). main( ) is declared as
Test ob = new Test(); static because it must be called before any objects exist.
// These are OK, a and b may be accessed directly  Instance variables declared as static are, essentially, global variables.
ob.a = 10;  When objects of its class are declared, no copy of a static variable is made.
ob.b = 20; Instead, all instances of the class share the same static variable.
// This is not OK and will cause an error  Methods declared as static have several restrictions:
// ob.c = 100; // Error! • They can only call other static methods.
// You must access c through its methods • They must only access static data.
ob.setc(100); // OK • They cannot refer to this or super in any way
System.out.println("a, b, and c: " + ob.a + " " + ob.b + " " + ob.getc());
} The following example shows a class that has a static method, some static variables, and a
} static initialization block:
 As you can see, inside the Test class, a uses default access, which for this example is // Demonstrate static variables, methods, and blocks.
the same as specifying public. b is explicitly specified as public. class UseStatic {
 Member c is given private access. This means that it cannot be accessed by code static int a = 3;
outside of its class. static int b;
 So, inside the AccessTest class, c cannot be used directly. It must be accessed through static void meth(int x) {
its public methods: setc( ) and getc( ). System.out.println("x = " + x);
 If you were to remove the comment symbol from the beginning of the following line, System.out.println("a = " + a);
// ob.c = 100; // Error! System.out.println("b = " + b);
}
Understanding static static {
 There will be times when you will want to define a class member that will be used System.out.println("Static block initialized.");
independently of any object of that class. b = a * 4;
 Normally, a class member must be accessed only in conjunction with an object of its }
class. public static void main(String args[]) {
 However, it is possible to create a member that can be used by itself, without meth(42);
reference to a specific instance. }
 To create such a member, precede its declaration with the keyword static. }
 As soon as the UseStatic class is loaded, all of the static statements are run.
  First, a is set to 3, class StaticByName {
 then the static block executes, which prints a message and then initializes b to a * 4 public static void main(String args[]) {
or 12. StaticDemo.callme();
 Then main( ) is called, which calls meth( ), passing 42 to x. System.out.println("b = " + StaticDemo.b);

 The three println( ) statements refer to the two static variables a and b, as well as to }
the local variable x. }
Here is the output of the program: Here is the output of this program:

Static block initialized. a = 42

x = 42 b = 99
a=3
b = 12 Introducing final
 A variable can be declared as final. Doing so prevents its contents from being
 Outside of the class in which they are defined, static methods and variables can be modified. This means that you must initialize a final variable when it is declared.
used independently of any object.  For example:
 To do so, you need only specify the name of their class followed by the dot operator. final int FILE_NEW = 1;

 For example, if you wish to call a static method from outside its class, you can do so final int FILE_OPEN = 2;

using the following general form: final int FILE_SAVE = 3;

classname.method( ) final int FILE_SAVEAS = 4;

 Here, classname is the name of the class in which the static method is declared. As final int FILE_QUIT = 5;

you can see, this format is similar to that used to call non-static methods through  Subsequent parts of your program can now use FILE_OPEN, etc., as if they were
object-reference variables. constants, without fear that a value has been changed.

 A static variable can be accessed in the same way—by use of the dot operator on the  It is a common coding convention to choose all uppercase identifiers for final
name of the class. This is how Java implements a controlled version of global variables.
methods and global variables.  Variables declared as final do not occupy memory on a per-instance basis. Thus, a
 Here is an example. Inside main( ), the static method callme( ) and the static variable final variable is essentially a constant.
b are accessed through their class name StaticDemo.  The keyword final can also be applied to methods, but its meaning is substantially
class StaticDemo { different than when it is applied to variables.
static int a = 42; Introducing Nested and Inner Classes
static int b = 99;  It is possible to define a class within another class; such classes are known as
static void callme() { nested classes. The scope of a nested class is bounded by the scope of its
enclosing class.
System.out.println("a = " + a);  A nested class has access to the members, including private members, of the class in
} which it is nested. However, the enclosing class does not have access to the members of the
nested class. A nested class that is declared directly within its enclosing class scope is a
} member of its enclosing class. It is also possible to declare a nested class that is local to a
block.
  There are two types of nested classes: static and non-static. A static nested class is one
that has the static modifier applied. Because it is static, it must access the non-static
members of its enclosing class through an object.

class Outerclass
{
…..
Class Nestedclass
{
……
}
}

• Scope of a nested class is bounded by the scope of its enclosing class.

• If class B is defined within class A, then scope of B is bounded by scope of A,
and B does not exist independently /without of A.[B not available outside A] .
• A nested class (B) has access to the members, including private members, of the
class in which it is nested (A).
• Eg: If B is a class defined inside class A, then B can access private members of
class A.
• The enclosing class does not have access to the members of the nested class.
• Eg: Class A cannot access members of class B. [need to create object]