-
Notifications
You must be signed in to change notification settings - Fork 3
Chapter 2 : Classes, Objects and Methods
Saket Khopkar edited this page Jan 5, 2022
·
6 revisions
- Class contains variables (data members) and functions (member functions / methods).
- A class is a template for an object, and an object is an instance of a class.
- Class is a collection of objects of similar types.
- Class is a user defined data type.
- Syntax:
class ClassName {
datatype instance-variable1; datatype instance-variable2;
:
datatype instance-variableN;
return_datatype methodName1(parameter-list)
{
// body of method
}
return_datatype methodName2(parameter-list)
{
// body of method
}
:
return_datatype methodNameN(parameter-list)
{
// body of method
} }
Description of Syntax:
- Class is defined using class keyword. ClassName is any valid java identifiers.
- Data or 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. The variables and functions defined inside the class are called members of the class.
- Class declaration only creates a template; it does not create an actual object.
- Class body written inside curly braces { and }. It does not terminate with semicolon.
import java.lang.*;
class Rectangle
{
int len, bre;
void getData(int l, int b)
{
len = l;
bre = b;
}
void putData()
{
System.out.print(“Area = “ + len*bre);
}
}
classRectArea
{
public static void main(String args[ ])
{
Rectangle r = new Rectangle();
r.getData(20,15);
r.putData();
}
}
// Output: Area = 300
-
Object is an instance of a class. Creating an object is called as instantiating an object.
-
An object is a block of memory that contains space to store instance variables and methods.
-
Once the class is defined we can create any number of objects of that class.
-
Objects are created by using new operator (dynamic memory allocation operator).
-
Steps for Creating Object: Creating objects of a class is a two-step process.
-
Step 1: 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.
-
Syntax: ClassName reference_variable;
-
Example: Rectangle r; // declare reference to object.
-
After this line executes r contains the value null, which indicates that it does not yet point to an actual object. Any attempt to use object rat this point will result in a compile-time error.
-
Step 2: Acquire an actual, physical copy of the object and assign it to that variable. We 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 the address of 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.
-
Syntax: reference_variable = new ClassName();
-
Here, reference_variable is a variable (object) of the class type being created. The ClassName is the name of the class that is being instantiated. The class name followed by parentheses specifies the constructor for the class.
-
Example: r = new Rectangle(); // allocate a Rectangle object
-
Above line allocates an actual object and assigns a reference of it to r. After this line executes, we can user as a Rectangle object. But in reality, r simply holds the memory address of the actual Rectangle object. The effect of these two steps of code is shown in Figure.
-
Above both statements can be combined into a single statement as follows:
-
ClassName object_name = new ClassName();
-
Rectangle r = new Rectangle();
-
Here Rectangle() is default constructor.
- One object reference can be assigned to another object reference variable, then the copy of the object is not created but copy of the reference is made.
Rectangle r1 = new Rectangle();
Rectangle r2 = r1;
- Here,r1 and r2 refer to same objects and no separate copy will be created. It simply makes r2 refer to the same object as r1.
- Thus, any changes made to the object through r2 will affect the object to which r1 is referring, since they are the same object.
- Although r1 and r2 both refer to the same object, they are not linked in any other way. For example, a subsequent assignment to r1 will simply unhook r1 from the original object without affecting the object or affecting r2.
- For example:
Rectangle r1 = new Rectangle ();
Rectangle r2 = r1;
// ...
r1 = null;
Here, r1 has been set to null, but r2 still points to the original object.
- Classes consist of two things: instance variables and methods. Syntax:
return_type function_name (parameter_list)
{
// body of method
}
- Example:
void calculate(int l, int b)
{
len = l;
bre = b;
System.out.print(“Area = “ + len*bre);
}
- Here, return_type specifies the type of data returned by the method. This can be any valid type, including class type. If the method does not return a value, its return type must be void.
- Methods that have a return type other than void return a value to the calling routine using the following form of the return statement: return value;
- The function_name of the method is 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. If the method has no parameters, then the parameter list will be empty.
- Data or 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.
- Syntax : datatype instance-variable1, instance-variable2, instance-variableN;
- Example : int a, b, c;
- Object contains data members (instance variables) and member functions (methods). Each object has its own memory space for data members.
- Object name and dot (.) operator is used to access variables and methods from outside the class.
- Variables and methods can be access directly from within the class.
- Syntax: object_name . Variable_name = value;
- Object_name . method_name(parameter_list);
- Example: r1.len = 20; r2.len = 10; r1.bre = 15; r2.bre = 8; r1.calculate (20, 15); r2.calculate (10, 8);
- Array of object is the collection of objects of the same class.
- The given syntax will define an array of reference, therefore assign object to individual reference in the array to declare the array of object.
- Method 1: ClassName array_name[]; array_name = new ClassName[size];
- Method 2: ClassName array_name[ ] = new ClassName[size]; Here, array_name is the array of object.
- Example:
Student s[];
s = new Student[5];
Or
Student s[ ] = new Student[5];
- It will create array of 5 objects of student class.
- We need to use constructor in order to construct array of objects as follows:
for(int i=0;i<=4;i++)
{
s[i] = new Student();
}
// Program to accept & display data of five students.
import java.io.*;
class Student
{
String name;
int rollno;
float per;
InputStreamReaderisr=new InputStreamReader(System.in);
BufferedReader br=new BufferedReader(isr);
void getData()
{
try
{
System.out.println("Input student details: ");
name=br.readLine();
rollno=Integer.parseInt(br.readLine());
per=Float.parseFloat(br.readLine());
}
catch(Exception e)
{
System.out.println("Exception Occurred: “ + e);
}
}
void putData()
{
System.out.println("Name = " + name);
System.out.println("Roll No = " + rollno);
System.out.println("Percentage = " + per);
}
}
class Program1
{
public static void main(String args[])
{
Student s[] = new Student[5];
int i;
for(i=0;i<=4;i++)
s[i] = new Student();
for(i=0;i<=4;i++)
s[i].getData();
for(i=0;i<=4;i++)
s[i].putData();
}
}
- We have seen previously that, object can be initialize in two ways:
- Use dot operator to assign values to instance variables individually.
- Use member functions / methods to initialize the instance variables.
- But both of these approaches are tedious. Simple solution for the above problem is to use constructor.
- Constructor is special member function which initializes an object when it is created. It is known as automatic initialization of object.
- Constructor is called automatically whenever an object of its class is created.
- It is called constructor because it constructs the values of data members of the class.
- Constructor name is same as that of class name.
- Constructors are called automatically when objects are created.
- Constructor does not have return type, not even void, and they cannot return values.
- Constructor cannot be inherited, though a derived class can call the base class constructor.
- We cannot refer to their address.
- Constructors make implicit calls to new when memory allocation is required.
- They are invoked automatically when the objects are created, so programmers need not to worry about calling constructor.
- It initializes the objects at run time while declaring it. So exact required memory will be allocated.
- It brings Class closer to built-in data type.
No, it’s not mandatory to use constructor in a class. When constructor is declared for a class, initialization of class objects becomes compulsory.
- Types of Constructors: There are basically two types of constructors:
- Default Constructor
- Parameterized Constructor
- Implicit Constructor
- Explicit Constructor
- Constructor that accepts no parameters is called as default constructor.
class Sample
{
int m,n;
Sample() // Default Constructor
{
m=n=0;
}
};
- If no such a constructor is defined then the compiler supplies a default constructor.
- Here a statement: Sample sobj = new Sample( );invokes (call) the default constructor.
// Program to demonstrate default constructor.
class Rectangle
{
int len,bre;
void Rectangle()
{
len = 10;
bre = 8;
}
}
void display()
{
System.out.println(“Area = “ + len*bre);
}
class DefaultCon
{
public static void main(String args[ ])
{
Rectangle r = new Rectangle ( ); // call default constructor
r.display( );
}
}
// Area = 80
- Constructor that accepts parameters is called as parameterized constructor.
class sample
{
int m,n;
sample (int x, int y) // Parameterized Constructor
{
m=x;
n=y;
}
};
- While creating objects we must pass one or more parameters in order to invoke this constructor.
- Above constructor can be invoked (call) as: samplesiobj = new sample(10,20);
// Program to demonstrate parameterized constructor.
class Rectangle
{
int len,bre;
void Rectangle(int l, int b)
{
len= l;
bre = b;
}
void display()
{
System.out.println(“Area = “ + len*bre);
}
}
class ParaCon
{
public static void main(String args[ ])
{
Rectangle r = new Rectangle (20, 15); // call parameterized constructor
r.display( );
}
}
// Output: Area = 300
- If programmer does not write any constructor, JVM or the java tool may provide the default constructor automatically. Such a constructor which is not coded by programmer is called as implicit constructor.
- The constructor which is explicitly written by the programmer is called as explicit constructor.
- Using more than one constructor in a class with different parameter list is called as multiple constructors in a class or constructor overloading.
- Proper constructor will be invoked based on parameters pass at the time of object declaration.
// Program to demonstrate constructor overloading.
class Area
{
int len,bre;
Area()
{
len=12;
bre=8;
}
Area(int l)
{
len=bre=l;
}
Area(int l,int b)
{
len=l;
bre=b;
}
void display()
{
System.out.println("Area = " + len*bre);
}
}
class ConsOverload
{
public static void main(String args[])
{
Area a1=new Area();
a1.display();
Area a2=new Area(7);
a2.display();
Area a3=new Area(20,15);
a3.display();
}
}
// Output: Area = 96
// Area = 49
// Area = 300
- When instance method or constructor is called by an object, then this pointer is used to point the current object under reference.
- The members of the current object like instance variables, methods and constructors can be referred by using this pointer. Use of this with constructor:
- Keyword this can be used within a constructor to call another constructor or nested constructor.
- In following program, class contains a set of constructors. Each constructor initializes some or all of the Cube’s member variables. Constructors provide a default value for any member variable whose initial value is not provided by an argument.
- Compiler first determines which constructor to call, based on the number and type of arguments.
// Program to demonstrate use of this with constructor.
class Cube
{
int length, breadth, height ;
public int printVolume( )
{
System.out.println (“Volume = “ + length * breadth * height );
}
Cube()
{
this(10, 10);
System.out.println("Finished with Default Constructor");
}
Cube(int l, int b)
{
this(l, b, 10);
System.out.println("Finished with Parametrized Constructor having 2 params");
}
Cube(int l, int b, int h)
{
length = l;
breadth = b;
height = h;
System.out.println("Finished with Parametrized Constructor having 3 params");
}
public static void main(String[] args)
{
Cube cubeObj1, cubeObj2;
cubeObj1 = new Cube();
cubeObj2 = new Cube(10, 20, 30);
cubeObj1.printVolume();
cubeObj2.printVolume();
}
}
// Output: Finished with Parametrized Constructor having 3 params
// Finished with Parametrized Constructor having 2 params
// Finished with Default Constructor
// Finished with Parametrized Constructor having 3 params
// Volume = 1000
// Volume = 6000
- Using same function name more than once in a class having different parameter list is called as method overloading.
- The difference may either in the number or types of parameters.
- Proper method will be invoked based on arguments pass at the time of function call.
- Java supports polymorphism through method overloading – “one interface, multiple methods”.
- Method overloading is used when objects are required to perform similar tasks but using different input parameters.
// Program to demonstrate constructor overloading.
Class Area
{
int len,bre;
void getVal()
{
len=12;
bre=8;
}
void getVal(int l)
{
len=bre=l;
}
void getVal(int l,int b)
{
len=l;
bre=b;
}
void display()
{
System.out.println(“Area = “ + len*bre);
}
}
class ConsOverload
{
public static void main(String args[])
{
Area a1=new Area();
a1.getVal();
a1.display();
Area a2=new Area();
a2.getVal(7);
a2.display();
Area a3=new Area();
a3.getVal(20,15);
a3.display();
}
}
// Output: Area = 96
// Area = 49
// Area = 300
- We need to use object and dot operator to call method of the class.
- A method can be called inside the body of another method of the same class. In this there is no need to use object and dot operator to call the method. It is known as nesting of methods.
// Program to demonstrate nesting of methods.
class Nesting
{
int m,n;
Nesting(int x,int y)
{
m=x;
n=y;
}
int largest()
{
if(m>=n)
return(m);
else
return(n);
}
void display()
{
int large=largest(); // nesting of methods
System.out.println("Largest Value="+large);
}
}
class NestingTest
{
public static void main(String args[])
{
Nesting n=new Nesting(50,40);
n.display();
}
}
// Output: Largest Value = 50
- The mechanism of deriving new class from existing class is called as Inheritance.
- The existing class is called as Base or Super class and new class is called as Derived or Sub class.
- In inheritance we can allow sub class to inherit some or all of the features of super class and add its own unique elements.
- Inheritance yields reusability, so it reduces development time and increases.
- Types of Inheritance:
- Single Inheritance: A derived class with only one base class is called as single inheritance.
- Multiple Inheritance: The mechanism of deriving a single class from multiple (more than one) base classes is called as multiple inheritance.
- Hierarchical Inheritance: The mechanism of deriving more than one derived classes from a single base class is called as hierarchical inheritance.
- Multilevel Inheritance: The mechanism of deriving a class from another derived class is called as multilevel inheritance.
- Hybrid Inheritance: The combination of more than one types of inheritance is called as hybrid inheritance. Note: Java does not support multiple inheritance.
- Advantages of Inheritance:
- Inheritance eliminates duplicate code in a program, thus provides idea of reusability.
- Inheritance reduces the development time. 3.Inheritance increases the productivity and reliability.
- Inheritance results in a better and smaller organization of code.
- Inheritance makes application program more flexible to change.
- Single Inheritance: A derived class with only one base class is called as single inheritance.
Syntax: class SubClassname extends SuperClassName
{
Body of sub class;
}
- Inheritance increases modularity.
// WAP to implement Single Inheritance, Use Constructors.
class Student
{
int rollno;
String name;
Student(int r, String n)
{
rollno = r;
name = n;
}
void put()
{
System.out.println("Roll Number : "+rollno);
System.out.println("Name : "+name);
}
}
class Exam extends Student
{
double percent;
Exam(int r, String n, double p)
{
super(r, n);
percent = p;
}
void output()
{
put();
System.out.println("Percentage : "+percent);
}
}
class Inheritance2
{
public static void main(String args[])
{
Exam e = new Exam(15, “Disha”, 89.25);
e.output();
}
}
// Output: Roll Number : 15
// Name : Disha
// Percentage: 89.25
- Subclass Constructor: A subclass constructor is used to construct the instance variables of both the subclass and the superclass. The subclass constructor uses the keyword super to invoke the constructor method of the superclass. The keyword super is used subject to the following conditions:
- Super may only be used within a subclass constructor method.
- The call to superclass constructor must appear as the first statement within the subclass constructor.
- The parameters in the super call must match the order and type of the instance variable declared in the superclass.
- Multilevel Inheritance: The mechanism of deriving a class from another derived class is called as multilevel inheritance. Syntax:
class B extends A
{
Body of B class;
}
class C extends B
{
Body of C class;
}
// WAP to implement Multilevel Inheritance.
class Student
{
int rollno;
String name;
void get(int r, String n)
{
rollno = r;
name = n;
}
void put()
{
System.out.println("Roll Number : "+rollno);
System.out.println("Name : "+name);
}
}
class Sports extends Student
{
int sport_marks;
void accept(int s)
{
sport_marks = s;
}
void display()
{
System.out.println(“Sports Marks : “+sport_marks);
}
}
class Exam extends Sports
{
double percent;
void input(double p)
{
percent = p;
}
void output()
{
put();
display();
System.out.println("Percentage : "+percent);
}
}
class Inheritance3
{
public static void main(String args[])
{
Exam e = new Exam();
e.get(15,"Disha");
e.accept(6);
e.input(89.25);
e.output();
}
}
// Output: Roll Number : 15
// Name : Disha
// Sport Marks : 6
// Percentage: 89.25
- Hierarchical Inheritance: The mechanism of deriving more than one derived classes from a single base class is called as hierarchical inheritance.
- Syntax:
class B extends A
{
Body of B class;
}
class C extends A
{
Body of C class;
}
class D extends A
{
Body of D class;
}
// WAP to implement Hierarchical Inheritance.
class A
{
int x;
void get()
{
x=10;
}
}
class B extends A
{
int p;
void calculate()
{
p=15;
System.out.println("Result B = " + p*x);
}
}
class C extends A
{
int q;
void calculate()
{
q=25;
System.out.println("Result C = " + q*x);
}
}
class D extends A
{
int r;
void calculate()
{
r=35;
System.out.println("Result D = " + r*x);
}
}
class Inheritance4
{
public static void main(String args[])
{
B bobj = new B( );
C cobj = new C( );
D dobj = new D( );
bobj.calculate();
cobj.calculate();
dobj.calculate();
}
}
// Output: Result B = 150
// Result C = 250
// Result D = 350
- We can use super keyword for two purpose as follows:
- To call Super Class constructor from Derived Class:
- Sub Class constructor can call Super Class constructor as follows:
super(); or super(parameter_list); - First form is used to call default constructor of super class where as second form is used to call parameterized constructor of super class.
- If super class is having no-argument constructor then it is not necessary to use super keyword in sub class constructor, in such case compiler automatically inserts a call to the no-argument constructor of super class.
- If super class is having parameterized constructor then it is compulsory for derived class constructor to have super keyword with proper parameters to call super class constructor, otherwise compile-time error will generate.
- Object is the highest level super class of Java, if subclass constructor invokes super class constructor, either explicitly or implicitly there will be whole chain of constructors called. It is called constructor chaining.
// Program to demonstrate use of super to call super class constructor.
class Student
{
int rollno;
String name;
Student(int r, String n)
{
rollno = r;
name = n;
}
void put()
{
System.out.println("Roll Number : "+rollno);
System.out.println("Name : "+name);
}
}
class Exam extends Student
{
double percent;
Exam(int r, String n, double p)
{
super(r, n);
percent = p;
}
void output()
{
put();
System.out.println("Percentage : "+percent);
}
}
class Inheritance2
{
public static void main(String args[])
{
Exam e = new Exam(15, “Disha”, 89.25);
e.output();
}
}
// Output: Roll Number: 15
// Name: Disha
// Percentage: 89.25
- To Access SuperClass Members:
- We can access members of super class that has been hidden (overridden) by the members of subclass. super.member;
class SuperClass
{
void show()
{
System.out.println(“Show of super class”);
}
}
class SubClass extends SuperClass
{
void show()
{
super.show(); // call show() of super class
System.out.println(“Show of sub class”);
}
public static void main(String args[])
{
SubClass s=new SubClass();
s.show(); // call show() of sub class
}
}
// Output: Show of super class
// Show of sub class
- In the class hierarchy, constructors are called in order of derivation, from super class to sub class.
- Since super() must be the first statement executed in a subclass constructor, this order is same weather super() is used or not.
- If super() is not used, then default or parameter less constructor of each super class will be executed.
class A
{
A()
{
System.out.println(“Inside A’s Constructor”);
}
}
class B extends A
{
B()
{
System.out.println(“Inside B’s Constructor”);
}
}
class C extends B
{
C()
{
System.out.println(“Inside C’s Constructor”);
}
}
class ConstExec
{
Public static void main(String args[])
{
C cobj = new C();
}
}
// Output: Inside A’s Constructor
// Inside B’s Constructor
// Inside C’s Constructor
- When a method in a subclass has the same name and type signature as a method in its superclass, then it is called as method overriding.
- When an overridden method is called from within a subclass, it will always refer to the subclass method. The superclass method will be hidden.
- Which function to call is depending on type of object used? If we use base class object then member function of base class get called, but if we use derived class object then member function of derived class get called.
// Program to demonstrate method overriding.
class BC
{
void show()
{
System.out.println("Base Class Show");
}
};
class DC extends BC
{
void show()
{
System.out.println("Derived Class Show");
}
};
class MOverride
{
public static void main(String args[])
{
BC bobj=new BC();
DC dobj=new DC();
bobj.show(); // calls base class show()
dobj.show(); // calls derived class show()
}
}
// Output: Base Class Show
// Derived Class Show
-
To declare constant / named constant
-
A variable can be declared as final, so its value cannot be modified. We must initialize a final variable when it is declared.
-
We must write down final variable name as all uppercase letters.
-
Variables declared as final do not occupy memory on a per-instance basis. Thus, a finalvariable is a constant.
-
Example:
final int PASSCRITERIA = 40;final float PI = 3.14f; -
Use of final with Inheritance:
- To prevent method overriding:
- To prevent a method from overriding, specify final as a modifier at the start of its declaration.
- Methods declared as final cannot be overridden.
class A
{
final void meth()
{
System.out.println("This is a final method.");
}
}
class B extends A
{
void meth()
{
// ERROR! Can't override.
System.out.println("Illegal!");
}
}
- Because meth( ) is declared as final, it cannot be overridden in B. If we try, a compile-time error will result.
- Methods declared as final can provide a performance enhancement. Compiler is free to inline call to them because they will not be overridden by a subclass. So it reduces overhead.
- Since final methods cannot be overridden, a callto it can be resolved at compile time. This is called early binding.
Using final to Prevent Inheritance:
- Keyword final can be used to prevent a class from being inherited. To do this, precede the
- Declaring a class as final implicitly declares all of its methods as final.
- It is illegal to declare a class as both abstract and final, as it is opposite concepts.
final class A
{
// ...
}
// The following class is illegal.
class B extends A
{
// ERROR! Can't subclass A
}
- It is illegal for B to inherit A since A is declared as final.
- Sometimes we want to define a superclass that declares the structure of a given abstraction without providing a complete implementation of every method.
- That is, sometimes we want to create a superclass that only defines a generalized form that will be shared by all of its subclasses, and each subclass will fill in the required details. Such a class is called as Abstract Class.
- When class contains one or more abstract methods, it must be declared as abstract class.
- We cannot create objects of the abstract class.
// Abstract Class
abstract class ClassName
{
// Body of abstract class
}
- By declaring methods as abstract it becomes compulsory for subclass to override that method.
- If subclass does not override abstract method of superclass then subclass also becomes abstract.
- These methods are sometimes referred to as subclasser responsibility because they have no implementation specified in the superclass.
- We cannot declare abstract constructor or static methods.
- If any method of the class is abstract then that class must also be declared as abstract. If a class contains an abstract method, the class must be abstract as well.
// Abstract Method
abstract return_type method_name(parameter-list)
{
// Body of abstract method
}
// Abstract Method and Class.
abstract class Base
{
abstract void show();
}
class Derived extends Base
{
void show()
{
System.out.println("Derived class show");
}
}
class AbstractCls
{
public static void main(String args[])
{
Derived d = new Derived();
d.show();
}
}
// Output: Derived class show
- A data member or member function of a class can be made static by using static keyword.
- Static variables are also known as class variables.
- Static member function can be called before creating any object of that class.
Characteristics:
- It initializes to zero when the first object of class is created. Other initialization is not permitted.
- A static members can be accessed using the class name instead of its objects as:
class-name . variable;class-name . function-name (); - Only one copy of static member is created for the entire class and is shared by all objects of that class.
- They are global in scope and its lifetime is the entire program.
- Static variables are normally used to maintain values common to the entire class.
- Static member function can have access to only other static members (functions & variables).
- A static member function cannot refer to this or super in any way.
- When to declare a member of a class static? When we want to maintain values common to the entire class then we declare member of a class as a static.
class student
{
static int passcriteria;
int percentage;
};
- Here, passing criteria remains same for all students so it is declared as a static. But percentage for every student may be different so percentage is non-static.
// Demonstrate static variables, methods, and blocks.
class MathOperation
{
static float mul(int a, int b)
{
System.out.println(“Multiplication = “ + a*b);
}
}
class MathApplication
{
public static void main(String args[])
{
MathOperation.mul(10,8); // called using class name
}
}
// Output: Multiplication = 80
- It is possible to define a class within another class; such classes are known as nested classes.
- The scope of a nested class is bounded by the scope of its enclosing class. Thus, if class B is defined within class A, then B is known to A, but not outside of 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.
- There are two types of nested classes:
- Static
- Non-static
- Static nested class is one which has the static modifier applied. Because it is static, it must access the members of its enclosing class through an object. That is, it cannot refer to members of its enclosing class directly. Because of this restriction, static nested classes are seldom used.
- Inner class is a non-static nested class. It has access to all of the variables and methods of its outer class directly in the same way that other non-static members of the outer class do. Thus, an inner class is fully within the scope of its enclosing class.
class A
{
-------
class B
{
-------
}
-------
}
- Local inner class is declared within the body of a method.
- Anonymous inner class is declared within the body of a method without naming it.
Reason for using the nested classes:
- Logical grouping of the classes
- Increased encapsulation
- More readable, maintainable code
- Dynamic method dispatch is the mechanism by which a call to an overridden method is resolved at run time, rather than compile time. It is use to achieve run-time polymorphism.
- In Java, a superclass reference variable can refer to a subclass object. Java uses this concept to resolve calls to overridden methods at run time.
- When an overridden method is called using a superclass reference, Java determines which version of the method to execute based upon type of the object referred at the time of the call.
- When different types of objects are referred, different versions of an overridden method will be called. In other words, it is the type of the object being referred to (not the type of the reference variable) that determines which version of an overridden method will be executed.
// Dynamic Method Dispatch
class A
{
Void callme()
{
System.out.println("Inside A's callme method");
}
}
class B extends A
{
Void callme()
{
System.out.println("Inside B's callme method");
}
}
class C extends A
{
Void callme()
{
System.out.println("Inside C's callme method");
}
}
class Dispatch
{
public static void main(String args[])
{
A a = new A(); // object of type A
B b = new B(); // object of type B
C c = new C(); // object of type C
A r; // obtain a reference of type A
r = a; // r refers to an A object
r.callme(); // calls A's version of callme
r = b; // r refers to a B object
r.callme(); // calls B's version of callme
r = c; // r refers to a C object
r.callme(); // calls C's version of callme
}
}
// Output: Inside A’s callme method
// Inside B’s callme method
// Inside C’s callme method
- Objects are dynamically allocated by using the new operator, but how such objects are destroyed and their memory released for reuse?
- In some languages, such as C++, dynamically allocated objects must be manually released by use of a delete operator.
- Java handles de-allocation of objects automatically. This technique is called garbage collection.
- When no references to an object exist, that object is considered 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 during the execution of your program.
- Furthermore, different Java run-time implementations will take different approaches to garbage collection.
- Object may 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 or window character font, then we might want to free these resources before an object is destroyed. To handle such situations, Java provides a mechanism called finalization.
- Finalization can define specific actions that will occur when an object is just about to be deleted by the garbage collector.
- To add a finalizer to a class, we simply define the finalize( ) method. The Java run time calls that method whenever it is about to delete an object of that class.
- Inside the finalize( ) method we 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 needed. Right before an object is deleted, the Java run time calls the finalize( ) method on the object.
General form of finalize( ):
protected void finalize( )
{
// finalization code here
}
- Here, the keyword protected ensures that finalize( ) cannot be accessed outside its class.
- Finalize( ) is not called when an object goes out-of-scope, this means we cannot know when finalize( ) will be executed. Therefore our program should provide other ways of releasing system resources, etc; used by the object. It must not rely on finalize( ) for normal program operation.