Simple Objects

Objects are similar to arrays of primitive types.
We will be using very simple object Coor1D
- represents the coordinate in 1D.
- composed of a number only.

package codes.teaching.java.visualization;

public class Coor1D {

  int x;

  public Coor1D(int x) {
    this.x = x;
  }
  
  ...

}

We start with empty symbol table and memory.
You can run the code by clicking
Switch to code button.

// simple object composed of primitive types

No variable does exist.
- Neither c1 nor c2.
Check the trace.
- A u indicates that the variable is undeclared

Coor1D c1;

declares variable c1 of type Coor1D.

Declaration causes two actions

an entry in the symbol table
Note
- The content of the symbol table entry has two information.
  - Name of the variable, in this case c1
  - Type of the variable, in this case Coor1D
- The color is changed. Anything that is related to Coor1D will have this color.
  - See color coding table.

Coor1D c1;

declares variable c1 of type Coor1D.

Declaration causes two actions

an entry in the symbol table
Note
- The content of the symbol table entry has two information.
  - Name of the variable, in this case c1
  - Type of the variable, in this case Coor1D
- The color is changed. Anything that is related to Coor1D will have this color.
  - See color coding table.
an entry in the memory
Note
- The content of the memory entry has - in it.
  - - indicates that the variable is uninitialized.
- The color is changed. Anything that is related to Coor1D will have this color.

Coor1D c1;

declares variable c1 of type Coor1D.

Declaration causes two actions

an entry in the symbol table
Note
- The content of the symbol table entry has two information.
  - Name of the variable, in this case c1
  - Type of the variable, in this case Coor1D
- The color is changed. Anything that is related to Coor1D will have this color.
  - See color coding table.
an entry in the memory
Note
- The content of the memory entry has - in it.
  - - indicates that the variable is uninitialized.
- The color is changed. Anything that is related to Coor1D will have this color.

This is the code of Coor1D:

package codes.teaching.java.visualization;

public class Coor1D {

  int x;

  public Coor1D(int x) {
    this.x = x;
  }

  public int getX() {
    return x;
  }

  public void setX(int x) {
    this.x = x;
  }

  public String toString() {
    return "(" + x + ")";
  }

  public static void main(String[] args) {
    Coor1D cA = new Coor1D(1);
    System.out.println(cA);
  }

}

c1 = new Coor1D(1);

causes two steps of actions:

new always means creation of a new object.
In this case, a new object of type Coor1D is created by calling the constructor
```
public class Coor1D {

  int x;

  public Coor1D(int x) {
    this.x = x;
  }
  ...
}
```
of Coor1D by means of
```
... new Coor1D(1)
```

c1 = new Coor1D(1);

causes two steps of actions:

new always means creation of a new object.
In this case, a new object of type Coor1D is created by calling the constructor
```
public class Coor1D {

  int x;

  public Coor1D(int x) {
    this.x = x;
  }
  ...
}
```
of Coor1D by means of
```
... new Coor1D(1)
```
Once the new object is created, its reference is stored in variable c1 by means of
```
c1 = new ...
```

In this example,

new object happen to be generated at location 12.
entry @12 in variable location 0 indicates
- the value is not here,
- this is a reference and
- the value is at location 12.

Coor1D c2 = new Coor1D(2);

is equivalent to

Coor1D c2
c2 = new Coor1D(1);

combined and done in one step.

It does multiple operations at once:

declares variable c2 of type Coor1D.
creates a new object of type Coor1D at location 11.
finally, associates c2 with the newly created object.

Note the similarity of

the path c2-@11-2
and
the path c1-@12-1

c1 = c2;

is a manipulation of references.

Before its execution,
- c1 refers to Coor1D object at location 12.

c1 = c2;

is a manipulation of references.

Before its execution,
- c1 refers to Coor1D object at location 12.
After its execution,
- c1 refers to Coor1D object at location 11.

Note that Coor1D object at location 11 can be access by both c1 and c2.

The main goal of this part is to show that the same object can be accessible by many variables.
We will see that this can be cause of some problems if we are not careful enough.

c1 = c2;

is a manipulation of references.

Before its execution,
- c1 refers to Coor1D object at location 12.
After its execution,
- c1 refers to Coor1D object at location 11.

Note that Coor1D object at location 11 can be access by both c1 and c2.

The main goal of this part is to show that the same object can be accessible by many variables.
We will see that this can be cause of some problems if we are not careful enough.

Note that

there is no way to access Coor1D object at location 12 now
- since there is no arrow to it.
the color of the object at location 12 is changed.

What happens to Coor1D object at location 12?

If this was the last reference to it,

then there is no way to access it. That means program cannot be able to use this object any more. That is the reason of the color change of the object at location 12

System

detects such cases and
marks these locations for garbage collection.

When systems decides it is time to do garbage collection,

it reclaims these unused locations to usable memory pool.

We will see that in steps 14 and 15.

See

We focus c1 for the next couple of statements.

c1.setX(9);

changes the coordinate of c1.

What would be the result of

System.outprintln(c1);
System.outprintln(c2);

Try out.

This innocent move also changes the coordinate of c2, too.
- The reason is that they are actually referring the same object.
Check the trace.
- How do you check if this is actually the case.
- Modify the code and run it to see by yourself.

c1 = new Coor1D(3);

is similar to

c1 = new Coor1D(1);

creates a new Coor1D object
associate c1 to this new one.

Note that

now c1 refers to new object
while c2 is not changed and keep referring to the previous one.

What would be the result of

System.outprintln(c1);
System.outprintln(c2);

Try out.

c1.setX(8);

is the same statement previously used,
except the parameter is set to 8:

c1.setX(9);

Both change the coordinate of c1. But the effects of the statement is different at this time.

The important point is that only the object at location 10, is changed.

it is referred by c1,

Why is the object at location 11 not changed?

It is obvious by looking the board
You should be able to see that reading the code without drawings. You will get there, keep practicing.

It is time to consider garbage collection.

Now focus on location 12.

It is allocated but cannot be used.
System should be able to reclaim it.

Suppose some more statements execute.

At some point
- systems decides that it needs some space.
The garbage collector runs and
- collects the unusable locations back to memory pool.

That's it.