What is difference between references and objects in java? [duplicate]

I have class GUI so I can create object like this:

GUI g1 = new GUI();

and a reference variable like this:

GUI g2;

Now as much as I know, g2 is a reference variable which gives reference to GUI class and g1 is an object of GUI class. What is the difference between g1 and g2? I can use property of GUI class with object but what is the possible usage of g2?

Solution 1:

References are names. Objects are stuff. You can have different names for stuff, even for stuff that doesn't actually exist.

You can declare names, without actually giving them any "real" meaning, like this:

GUI g1;

You can assign meaning (real stuff to refer to) to names with the = operator:

GUI g1 = some_gui;

Names can change their meaning over time. The same name can refer to different things at different points in history.

GUI g1 = some_gui;

doSomething();

g1 = some_other_gui;

There are also synonyms: multiple names can refer to the same thing:

GUI g2 = g1;

That's pretty much what references do. They are names meant to refer to stuff.

Stuff can be created:

new GUI();

Stuff can be created and named on the spot for later reference (literally!):

GUI g1 = new GUI();

And stuff can be referred to, using its name (or any of its names!):

g1.doSomething();
g2.doSomethingAgain();

Different stuff of the same kind (Class) can be created, and named differently:

GUI g1 = new GUI();
GUI g2 = new GUI();
GUI g3 = new GUI();

GUI g1_synonym = g1;

Solution 2:

What is difference between references and objects in java?

A reference is an entity which provides a way to access object of its type. An object is an entity which provides a way to access the members of it's class or type.

Generally, You can't access an object without a reference to it.

class GUI
{
    void aMethod()
    {
        // some business logic.
    }
}

You can call aMethod with or without a reference. but you definitely need an object.

Without Reference:

new GUI().aMethod(); 
// you can't reuse the object
// bad way to code.

With Reference:

GUI aGUIReference = new GUI();
aGUIReference.aMethod();
// Now, the object can be reused.
// Preferred way to code

Now a little explanation to your code lines:

GUI g1 = new GUI();
// g1 is a reference to an object of GUI class.

GUI g2;
// g2 is a reference that can point to an object of GUI class
// but currently not pointing to any.

The only difference b/w g1 and g2 is that g1 is initialized with an object but g2 points to null

g2 = g1;
// it means g2 will point to the same object g1 is pointing to
// only one object but two references.

Solution 3:

You are not able to use g2 until you assign an object to it, since currently it does not point to any object, while g1 already points to a GUI object and you may use it.

This:

GUI g1 = new GUI();

is pretty much equivalent to:

GUI g1;
g1 = new GUI();

Solution 4:

References are sort of pointers to a block of memory called objects.

GUI g1 = new GUI();

For explanation, let me break the above statement.

GUI g1;
g1 = new GUI();

1st step: g1 is a reference variable (pointer), not yet pointing to any valid memory location.

2nd Step: The second step allocates the memory for object of class GUI and the assignment operation make the reference variable g1 point to this object (memory location). The new keyword allocates the memory for the object of class GUI.

Solution 5:

Objects are like bubbles floating through a space called heap. Variables are merely links to these bubbles. The expression new GUI() creates an object and = operator links it to the variable g1. g2 is also a variable but it's not linked to any object. You can easily swap them by writing

g2 = g1;
g1 = null;

Now g2 refers to the object that g1 was referring to in the beginning, and g1 refers to nothing. The object is intact, only the variables was changed.