Java: Creating objects without naming them?

Question

I'm currently reading Sam Teach Yourself Java in 21 days 6th Edition by Rogers Cadenhead.

There is an example in the book that shows object creation using a for loop in one of the chapters on static variables and methods.

The code is as follows:

public class InstanceCounter {
    private static int numInstances = 0;

    protected static int getCount() {
        return numInstances;
    }

    private static void addInstance() {
        numInstances++;
    }

    InstanceCounter() {
        InstanceCounter.addInstance();
    }

    public static void main(String[] arguments) {
        System.out.println("Starting with " +
            InstanceCounter.getCount() + " objects");
        for (int  i = 0; i < 500; ++i)
            new InstanceCounter();
        System.out.println("Created " +
            InstanceCounter.getCount() + " objects");
    }
}

I do not understand how the for loop can create objects without actually giving these 500 new objects names. This is how I have been taught to create objects:

Object Objectname = new Object();

Is the for loop just going to create these objects and discard them straight afterwards as they have no Objectname?

I see that when I type the code into Netbeans, the hint says "New Instance ignored".

T x = new T() causes a new instance of T to be referenced by the variable x. It's pretty much like keeping track of the objects you create on a piece of paper. If you don't write it down then it will still exist but you can't pinpoint it because it can't be named; if you do write it down you can refer to it by the name you gave it in your list. — Jeroen Vannevel
– Jeroen Vannevel, Commented Jan 19, 2014 at 15:20

yyunikov · Accepted Answer · 2014-01-19 15:23:10Z

2

At the line new InstanceCounter(); the new object is created. However if you don't have any reference to it, you will not be able to access it and probably it will be garbage collected soon. If you want to keep the reference to it, just add something like you wrote here Object objectname = new Object();. Then the objectname will be the reference of the class Object.

Your static methods do not refer to your objects, they refer to class InstanceCounter. Even if some instances will be garbage collected by GC, the number of instances that was created will be kept in variable numInstances.

edited Jan 19, 2014 at 15:23

answered Jan 19, 2014 at 15:17

yyunikov

5,9175 gold badges47 silver badges80 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Peter Lawrey · Accepted Answer · 2014-01-19 15:17:55Z

1

Objects don't have names, so you create as many as you like with out a name.

References such a fields and local variables can name names. You can reuse those variables and names in a loop as many times as you like, or not. Whether you assign the reference to an object to a name or not is up to you.

answered Jan 19, 2014 at 15:17

Peter Lawrey

535k83 gold badges770 silver badges1.2k bronze badges

Comments

Kokozaurus · Accepted Answer · 2014-01-19 15:18:55Z

What you refer by saying Objectname is called reference in Java, and is used to access an object after it has been created. If you do not create a reference and assign an object to it, you can operate with it in the scope of a single expression e.g.:

(new Random()).nextInt();

will return a random Integer object and then leave the garbage collector deal with the object of type Random. This means that you can not use the same object again, So It seems you are right.

Of course to use the same object you need some kind of reference like:

Random someGenerator = new Random();

where the left side of the assignment is the declaration of the reference, or also you can put the new object into some kind of collection:

List<Random> randList = new LinkedList<Random>();
randList.add(new Random());

This way you can access those objects even without them having a separate reference. You can think of those collections as a group reference to objects of the same type.

Orel Eraki · Accepted Answer · 2014-01-19 15:22:10Z

1

Creating an instance is just a simple action of new SomeInstance(). We choose whatever to save them for further use or ignore them and in normal case we usually save them.

The conventional way is to save them like this:

SomeInstance mySomeInstance = new SomeInstance()

If we choose to create them without saving them OR somewhere in the code we will no longer need them than the almighty Garabage Collection will clean them up.

answered Jan 19, 2014 at 15:22

Orel Eraki

12.2k4 gold badges31 silver badges38 bronze badges

Comments

Martin Dinov · Accepted Answer · 2014-01-19 16:00:44Z

1

They may or may not be discarded soon after creation. When there are no more references to an object, the GC (garbage collector) will eventually remove it, so these non-referenced objects will too eventually get GC'ed when the GC runs. With the static method addInstance() you are just keeping track of how many of these "anonymous objects" were created. This is not a measure of how many are still around though, as it's just a static int that's counted how many were created.

edited Jan 19, 2014 at 16:00

answered Jan 19, 2014 at 15:18

Martin Dinov

8,8553 gold badges31 silver badges42 bronze badges

Collectives™ on Stack Overflow

Java: Creating objects without naming them?

5 Answers 5

Comments

Comments

Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

5 Answers 5

Comments

Comments

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related