Some basic concepts between objects and references

Java objects and their references

Some basic concepts between objects and references.

When I first learned Java, for a long time, I always felt that the basic concepts were very vague. Later I learned that in many Java books, objects and object references are confused. However, if I can't distinguish between objects and object references,

then I really can't understand the following object-oriented technology well. Writing down some of your own knowledge may help friends who are new to Java avoid taking some detours.

For the convenience of explanation, we first define a simple class:

class Vehicle {

int passengers;

int fuelcap;

Int mpg;

}

With this template, you can use it to create an object:

VEHILLE VEH1 = New Vehicle (); The action of this statement is usually called creating an object. In fact, it contains four actions.

1) The "new Vehicle" on the right uses the Vehicle class as a template to create a Vehicle class object (also referred to as a Vehicle object) in the heap space.

2) The () at the end means that after the object is created, the constructor of the Vehicle class is called immediately to initialize the newly generated object. There is definitely a constructor. If you don't write it, Java will add a default constructor for you.

3) "Vehicle veh 1" on the left creates a Vehicle class reference variable. The so-called Vehicle class reference is an object reference that can be used to point to the Vehicle object in the future.

4) The "=" operator makes the object reference point to the newly created Vehicle object.

We can split this statement into two parts:

Vehicle veh1;

veh1 = new Vehicle();

The effect is the same. Written this way, it is clearer. There are two entities: one is the object reference variable, and the other is the object itself.

The entities created in the heap space are different from the entities created in the data segment and stack space. Although they are real entities, we cannot see or touch them. Not only that,

Let’s study the second sentence carefully and find out what is the name of the object we just created? Some people say it's called "Vehicle". No, "Vehicle" is the name of the class (the object's creation template).

A Vehicle class can create countless objects, and these objects cannot all be called "Vehicle".

The object does not even have a name, so it cannot be accessed directly. We can only access objects indirectly through object references.

In order to vividly illustrate objects, references and the relationship between them, you can make a metaphor that may not be very appropriate. The object is like a very big balloon, too big for us to catch. The reference variable is a rope that can be used to tie the balloon.

If only the first statement is executed and the second statement is not executed, the reference variable veh1 created at this time does not point to any object, and its value is null. A reference variable can point to an object or be null.

It is a rope, a rope that has not yet been tied to any balloon. After executing the second sentence, a new balloon is made and tied to the rope veh1. When we grab the rope, we grab the balloon.

One more sentence:

Vehicle veh2;

I made another rope, but I haven’t tied the balloon yet. If you add another sentence:

veh2 = veh1;

is tied. Here, copying behavior occurs. However, it should be noted that the object itself is not copied, only the object reference is copied. As a result, veh2 also points to the object pointed to by veh1. The two ropes are tied to the same balloon.

If you use the following sentence to create another object:

veh2 = new Vehicle();

, the reference variable veh2 will change to point to the second object.

From the above narrative, we can get the following conclusions:

(1) A object reference can be directed to 0 or 1 object (a rope can not be auto ball, and it is also not the ball, and it is also not the ball, and it is also not the ball. You can tie a balloon);

(2) An object can have N references pointing to it (you can have N ropes tie a balloon).

If you come again, the following sentence:

Veh1 = Veh2;

According to the above inference, veh1 also points to the second object. no problem. The question is where is the first object? There was no rope to hold it and it flew away. Most books say that it is recycled by Java's garbage collection mechanism.

This is not exact. Correctly speaking, it has become the subject of garbage collection. As for when it will actually be recycled, it depends on the mood of the garbage collection mechanism.

From this point of view, the following statement should be illegal, right? At least it's useless, right?

new Vehicle();

Wrong. It's legal and available. For example, if we create an object just for printing, we don't need to tie it to a reference variable. The most common is to print a string:

System.out.println("I am Java!");

The string object "I am Java!" is discarded after printing. Some people call this kind of object a temporary object.

The relationship between the object and the reference will continue until the object is recycled

Java only processes alias references at runtime

The above is the detailed content of Some basic concepts between objects and references. For more information, please follow other related articles on the PHP Chinese website!