Reference Variables, Objects and Anonymous objects

Java includes two types of variables primitive variables and reference variables.
A primitive type refers a primitive data type and reference type refers a class. Observe
the following which you are well acquainted.
1
2
3
4
5
6
7
8
9
10
11
12
public class Demo
{
int x = 10;
public static void main(String args[])
{
Demo d1;
// System.out.println(d1.x);

d1 = new Demo();
System.out.println(d1.x);
}
}
We have created and used many objects in all the previous programs. Now let us analyze
the code of creating an object.
The general way of creating an object is of the following format.
Demo d1 = new Demo();
In the above statement, we say, object d1 of Demo class is instantiated.
What is an object and instance?
Generally a C++ programmer says immediately, "an instance of a class is known as
object". Of course, he is very right but the statement will be very confusing to a novice.
Let us be clearer through some common day-to-day example. We cut a tree and get the
wood. How to make use of the wood? Wood itself is waste as we cannot use it straight
away. The wood should be converted into objects like door, table and duster and then
used. Without these objects, simply, wood is waste. We say door, table and duster are
the instances of wood. Door is an object of wood or we can say, the door is an
instance of wood.
Similarly we have a class containing constructors, variables and methods (all these are
known as constructs of a class). How to make use of them? We require objects of the
class. Using these objects we can access the contents of the class. The object is d1. With
d1, all the contents of the class can be made use of. Now we can say, the instance of a
class is object. For this reason object creation is known as instantiation. No object,
class is simply waste (like no door, wood is waste).
What is reference variable?
Demo d1 = new Demo();
The above statement can be split into two as follows.
Demo d1; // 1st
d1 = new Demo(); // 2nd
In the first statement, d1 is called a reference variable (not object). A variable that
refers a class name is known as reference variable. A reference variable cannot
work like an object until it is converted into an object. In the second statement,
reference variable is converted into an object.
Who has converted the reference variable into an object?
There are two words on the right side; new and Demo(). Demo() is known as
constructor. What a constructor returns? Generally, it is said that constructor does not
return a value, but still we do not write void. Why, because the constructor really returns
something. The constructor returns an object of a class known as "class object". This
"class object" does not have a name. The nameless object in Java is known as
"anonymous object". That is, a constructor returns an anonymous object. The
anonymous object (returned by the constructor) is assigned to the reference variable d1.
Now d1 is called an object. When object has a name, the new operator allocates
memory for the d1 object. Any object in Java takes four bytes of memory. Now d1 object
exists in the memory and can be used throughout the program to call a method or
variable, any number of times.
How can we use reference variables in a program?
Just we came to know, a reference variable cannot work like an object until it is
converted. But still, reference variables can be used to assign with an object. Observe the
following.
Demo d1 = new Demo(); // an object
Demo d2, d3; // reference variables

System.out.println(d1.x); // prints 10
d2 = d1; // an object is assigned to a reference variable
System.out.println(d2.x);
// prints 10 as now reference variable works like
an object

d3 = d2; // reference to reference
System.out.println(d3.x); // prints 10
Now even through d2 and d3 are reference variables but still they are used as objects to
call x value. What happened? How they print? When assigned, d1, d2 and d3 refer the
same location of x. What is the proof? See the following code.
d2.x = 20;
System.out.println(d1.x); // prints 20
System.out.println(d2.x); // prints 20
System.out.println(d3.x); // prints 20
All prints 20 as all point to the same location. If one changes, others also gets affected.;
no encapsulation.
How anonymous objects are useful in the program?
d1 = new Demo();
In the above statement, the right-side expression, new Demo(), is known as
anonymous object. If an anonymous object is not assigned a value, like d1, what
happens to the anonymous object.
new Demo();
In the above statement, d1 is not assigned. The anonymous object is created and dies
instantaneously. But, still with anonymous objects work can be extracted before it dies
as follows.
1
2
3
4
public class Demo
{
int x = 10;
public void display()
5
6
7
8
9
10
11
12
13
14
15
16
{
System.out.println("Hello 1");
}
public static void main(String args[])
{
System.out.println(new Demo().x);
System.out.println(new Demo().x);
System.out.println(new Demo().x);
new Demo().display();
new Demo().display();
}
}
As you can observe in the code, the anonymous object can be used only once in the
program. We cant use twice or more as the anonymous object dies immediately after
doing its assigned task (here printing x and calling display()). Java designers advice to
use anonymous objects when the object is required only once in the program. The
advantage is to save memory, as anonymous object dies immediately. In I/O streams
and AWT, we use many objects only once in the program; for them, better go for
anonymous objects as follows.
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
g.setColor(new Color(100, 200, 80));
In the above two statements, anonymous objects of InpputStreamReader and Color are
used.
Java also supports anonymous inner class objects
- See more at: http://way2java.com/oops-concepts/reference-variables-anonymous-
objects/#sthash.NgZoyCw8.dpuf