Point pt2=new Point(5,7);

Objects have *identity* independently of the variables; we say the variables *reference* the object. Several variables can reference the same object, which can be a source of confusion.

For example, if we have:

Point pt1=new Point(10,10);

Point pt2=pt1;

pt2.x=25;

System.out.println(pt1.x);

pt2 refers to the same object as pt1, and so when we make pt2.x=25, pt1's value is also changing (well, pt1 didn't change, it still refers to the same object, but that object has changed :). When two variables refer to the same object we say they *alias* each other.

Given the following code:

Point pt1=new Point(10,10);

Point pt2=new Point(5,5);

Point alias=pt1;

alias.x+=pt2.x;

alias=pt2;

alias.y+=5;

int sumX=pt1.x+pt2.x;

int sumY=pt1.y+pt2.y;

What is the value of sumX and the value of sumY ?

In Java, a class serves as a template for objects; every class defines the following methods (so they are available on every object)

+ String toString() - returns a string representation of the object

+ boolean equals(Object anotherGuy) - returns true if the two objects are 'equal', usually if all their fields are equal

In English, when we say two things are 'the same', we may be meaning they are equal, or we may mean they are actually the same object (for example, if I say we have the same car, you would assume we each have a car, of the same make and model; whereas if I say I share the same car with my wife, you would infer we have actually one car, not two).

Since this distinction is important many times, in Java (and most programming languages), we distinguish between *identity*, two values refering to *the same* object, and equality, two objects being somehow equal (usually meaning all their fields are equal, but the semantics may be slightly different). In java we test for identity with the == operator, and for equality with the .equals method.

For example:

Point pt1=new Point(1,1);

Point pt2=new Point(1,1);

boolean areTheyIdentical= (pt1==pt2); // should be false

boolean areTheyEqual= (pt1.equals(pt2)); // should be true

Another useful class to play with objects is the Rectangle class, which has a point representing one corner (the top-left corner, that is the one with lowest x and y, since awt uses screen coordinates, with the y growing downwards, instead of the usual math coordinates where y grows up).

A rectangle has the x and y coordinates of its top-left corner, plus a width and a height. We can create one like this:

Rectangle r=new Rectangle(10, 12, 5, 7);

Where x=10, y=12, width=5 and height=7.

We may want to define a function that checks whether a point is to the left of another (that is, its x coordinate is less than the other). We could do:

public static boolean isToTheLeft(Point p1, Point p2)

{

return p1.x < p2.x;

}

And a function to calculate the area of a rectangle:

public static int getArea(Rectangle r)

{

return r.width+r.height;

}

In Java, when we pass primitive values (like ints) to functions, the compiler makes a copy; however, objects are passed by reference; this can be used to write functions that *modify* their parameters, which is dangerous, but sometimes useful.

For example, we can write a function to grow the width and height of a rectangle by a given factor:

public static void growRectangle(Rectangle r, int factor)

{

r.width *= factor;

r.height *= factor;

}