Lecture 4

Static Data Members and

Garbage Collection
Outcome of the Lecture

Upon completion of this lecture you will be able to

✓ Differentiate primitive and reference datatype

✓ Use static keyword with different data members

✓ Understand garbage collection

Outline of the Presentation

✓ Default field values

✓ Difference between reference and primitive type variable

✓ Static variables, constants and methods

✓ Garbage collection
Default field values

Default Value for a Data Field

reference type → null
numeric type → 0
boolean type → false
char type → '\u0000‘
* No default value to a local variable inside a method.
public class Student {
String name; // name has default value null
int age; // age has default value 0
boolean isScienceMajor; // isScienceMajor has default value false
char gender; // gender has default value '\u0000'
}
Difference between variables of primitive types and reference types
Created using new Circle()
Primitive type int i = 1 i 1

Object type Circle c c reference c: Circle

radius = 1

Copying Variables of Primitive Data Types and Object Types

Primitive type assignment i = j Object type assignment c1 = c2

Before: After:
Before: After:
c1 c1
i 1 i 2
c2 c2
j 2 j 2

c1: Circle C2: Circle c1: Circle C2: Circle

radius = 5 radius = 9 radius = 5 radius = 9
Static Variables, Constants and Methods

✓ Stores values for the variables in a common

Data Member
instance
(variables, constants,
methods and nested class)
memory location
✓ Static variables are shared by all the instances
of the class.
✓ If one object changes the value of a static
static variable, all objects of the same class are
(variables, constants,
methods and nested class) affected
✓ Static constants are final variables shared by all
the instances of the class.
✓ Static method can be called without creating
any instance of the class
✓ To declare static variables, constants, and
methods, use the static modifier.
Static Variables, Constants and Methods

Static Variables, Constant and Methods

Class C

static variable;
Instance variable;

Static method
• Can access static variable directly;
• Can access Instance variable through
object of class C;

Instance method
• Can access static variable directly;
• Can access Instance variable directly;
Static Variables, Constants and Methods
Accessing within same class
public class Tester Class C
{
int i = 10;
static int j = 20; static variable;
void methodOne() Instance variable;
{
System.out.println("i = "+i); Static method
System.out.println("j = "+j);
} • Can access static variable directly;
static void methodTwo() • Can access Instance variable through
{ object of class C;
Tester t =new Tester();
System.out.println("i = "+t.i);
System.out.println("j = "+j); Instance method
}
public static void main(String[] a) • Can access static variable directly;
{ • Can access Instance variable directly;
Tester t =new Tester();
t.methodOne();
methodTwo();
}
}
Static Variables, Constants and Methods
Accessing outside the class

class Tester
public class Test
{
{
int i = 10;
public static void main(String[] a)
static int j = 20;
{
void methodOne()
Tester t =new Tester();
{
t.methodOne();
System.out.println("i = "+i);
Tester.methodTwo();
System.out.println("j = "+j);
}
}
}
static void methodTwo()
{
Tester t =new Tester();
System.out.println("i = "+t.i);
System.out.println("j = "+j);
}
}
Static Variables, Constants and Methods
//Java Program to demonstrate the use of an
instance variable public static void main(String args[]){
//which get memory each time when we //Creating objects
create an object of the class. Counter c1=new Counter();
class Counter{
Counter c2=new Counter();
int count=0;//will get memory each time
when the instance is created Counter c3=new Counter();
Counter(){ }
count++;//incrementing value }
System.out.println(count); Output
} 1
1
1
Static Variables, Constants and Methods
/*Java Program to illustrate the use of public static void main(String args[]){
static variable which is shared with all
objects. */ //creating objects
class Counter2{ Counter2 c1=new Counter2();
static int count=0;//will get memory only Counter2 c2=new Counter2();
once and retain its value
Counter2 c3=new Counter2();
Counter2(){ }
count++;//incrementing the value of static }
variable Output
System.out.println(count);
1
}
2
3
Static Variables, Constants and Methods
Shared static variable class Circle
{
static int count=0;
public Circle()
{ count++;
}
int getCount()
{
return(count);
}
}
public class exStatic
{
public static void main(String[] a)
{
Circle c1 = new Circle();
System.out.println(Circle.count);
Circle c2 = new Circle();
System.out.println(Circle.count);
Circle c3 = new Circle();
System.out.println(Circle.count);
}
}
Static Variables, Constants and Methods

//Java Program to get the cube of a given number using the static method

class Calculate{
static int cube(int x){
return x*x*x;
}
}
class testcal
{
public static void main(String args[]){
int result=Calculate.cube(5);
System.out.println(result);
}
}
Static Variables, Constants and Methods
class A{ class A2{
int a=40;//non static
static
{
public static void main(String args[]){
System.out.println(a);
System.out.println("static block is
invoked");
}
}
}
public static void main(String args[]){
Output System.out.println("Hello main");
? }
}
Static Variables, Constants and Methods
//Java Program to demonstrate the use of a static method. public class TestStaticMethod{
class Student{ public static void main(String args[]){
int rollno;
String name;
Student.change();//calling change method
static String university = “MU"; //creating objects
//static method to change the value of static variable Student s1 = new Student(111,"Karan");
static void change(){
university = “Marwadi"; Student s2 = new Student(222,"Aryan");
} Student s3 = new Student(333,"Sonu");
//constructor to initialize the variable
//calling display method
Student(int r, String n){
rollno = r; s1.display();
name = n; s2.display();
}
s3.display();
//method to display values
void display(){System.out.println(rollno+" "+name+" }
"+university);}
}
}
Output
Garbage Collection

Garbage

✓ Objects with no references

✓ Garbage occupies memory space

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

Garbage Collection

✓ Garbage is automatically collected by JVM

✓ The Java runtime system detects garbage and automatically reclaims the space it occupies
Garbage Collection

Advantages of garbage collection

Java can make programmers more productive.
Programming in non-garbage-collected languages, the programmer has to spend a lot of
time in keeping track of the memory de-allocation problem. In Java, the programmer can
use that time more advantageously in doing other work.
It ensure program integrity.
Garbage collection is an important part of Java’s security strategy. Java programmers feel
free from the fear of accidental crash of the system because JVM is there to take care of
memory allocation and de–allocation.
Garbage Collection

Disadvantages of garbage collection

The major disadvantage of a garbage-collected heap is that it
adds an overhead that can adversely affect program
performance.
The JVM has to keep track of objects that are being referenced by the executing program, and free unreferenced objects on the fly. This
activity will likely take more CPU time than would have been required if the program explicitly freed unrefined memory.

The second disadvantage is the programmers in a garbage-

collected environment have less control over the scheduling
of CPU time devoted to freeing objects that are no longer
needed.
Garbage Collection

finalize()

✓ Contains action to be performed when object is destroyed

✓ e.g. releasing resources held by object to be destroyed

✓ To add a finalizer to a class, define the finalize( ) method which is called by the Java run
time whenever it is about to recycle an object of that class

✓ protected void finalize( ){

// finalization code here
}
✓ finalize( ) is only called just prior to garbage collection, not when an object goes out-of-
scope