Data Objects (revisited) Recall that values are stored in data objects, and that each data object holds one value of a particular type. Data objects may be labeled with names – variables. The variable refers to the data object, and when we set the variable to a value, we replace the value in the data object. When we use the variable in an expression, we retrieve the value stored in the data object.

References For primitive types (int, char, etc.) we can think of the variable has storing the value of the particular type. However, this is different for object variables. An object variable contains a reference to the data object where the values are actually stored. This is an importance difference.

An Analogy You live in a house. The house has an address. The address is not the same as the house, but can be used to refer to the house. If you say 'so-and-so' lives at 1313 Mockingbird Lane you really mean that 'so-and-so' lives at the house at 1313 Mockingbird Lane. We often confuse the address with the actual house. This is not a problem for human beings.

Analogy (cont'd) Similarly, data objects have addresses (for example, the address could be the address of the memory location in RAM where the data object is electronically stored. The address is not the same as the data object, but can be used to refer to the data object and its contents.

So What? A primitive variable can be thought to hold a value of its type. But an object variable holds the address (reference) to the data object of its type. The program will automatically fetch the data object when you use the variable, i.e., go the house and get (or replace) the person there, but the variable really holds the address.

Still, So What? Here's the point: Suppose that we create an object, say a Snowman: Snowman steve = new Snowman(); and then we set another variable to have the same value: Snowman x = steve; Then steve and x hold the same address, that is, they refer to the same data object.

This is What Changing the properties of the Snowman that the variable steve refers to also changes the properties of the Snowman that x refers to (since they are the same Snowman or data object). So, steve.setColor( " red " ); System.out.prinln(x.getColor()); would print out " red ".

Changing Variables It is important to note that changing the properties of the object is different than changing the variable. For example, Snowman dave = new Snowman(); x = dave; would make x refer to the same Snowman the dave refers to.

Summary  Object variables hold references to (addresses of) data objects.  If two object variables refer to the same data object, changing the properties of the data object affects both.  An assignment statement can be used to make an object variable point to a different data object.

Parameters This difference applies to parameters as well. If a parameter is a primitive type, its value is initialize to be the value of the corresponding argument (in the call to the method). The value is copied into the data object which that variable names.

Parameters (cont'd) If a parameter is an object type, the value of the argument is also copied to the parameter. But since the value is a reference to the data object, both the parameter and the argument refer to the same data object.

Changing Values If you change the value of a parameter of a primitive type in the method, it has no effect on the value of the argument, since the parameter has a copy of that value. But, if you change the properties of the data object that a parameter of object type refers to, it changes the properties of the data object that the argument refers to, since they are the same data object.

Example – Primitive type parameter public class Foo { public static void incr(int x) { x = x + 1; }... In main: int n = 5; Foo.incr(n); // n doesn't change.

Example Object Type Parameter public class Foo { public static void change(Snowman x) { x.changeColor( " red " ); }... In main: Snowman steve = new Snowman() Foo.change(steve); // steve changes color

Exercise Write a program, Fraud.java, that allows one to change the balance in their bank account, even though the balance field is private.

Solution To avoid allowing one to change the properties of an object (such as balance), a common trick is to return a copy of the object. Thus changing the copy does not change the original. A copy constructor is often used to make copies of the object. It is a one-argument constructor that takes an object and copies the fields to a new object.

Solution (cont'd) Remember that if fields of the object are themselves objects (example: the snowman's head), then those fields need to be copied as well.

Other pitfalls The equality operator (==) checks if two objects are the same, that is, they are the same data object (in memory). It does not check that they may be two different objects, but having the same properities, i.e., account number, balance, APR. The equals method should be used instead. This method should compare the fields for equality.

The Constant null The constant null is a special constant that may be assigned to a variable of any class type. It does not refer to any object – and that's the point. When we have a variable that doesn't refer to anything, we set it to null. It is a placeholder. For example, if a person did not have a bank account, their bankaccount field would be set to null.

Null (cont'd) This may create a problem. It means that we have to check that an object variable is not null before using the object it refers to. So, many of our methods (equals, compareTo) should check that the argument is not null before trying to process it. If you don't, you may get the dreaded Null Pointer Exception

Packages A package is how we can form libraries of classes. A package is a collection of classes that has been grouped together in a directory and given a package name. A package is made available to another program by using the import statement. For example, import java.util.Scanner; will import one class of a package.

Packages (cont'd) We can import all the classes of a package by using a wildcard: import java.util.*; The import statement must come at the top of the program.

Creating Package To create a package, we put all of the files into one directory (and where the directory is will be important) and add a package line to each file: package java.util; This line must come at the beginning of the file.

Package Names and Directories The name of the package is part of the path name to the directory containing the classes of the package. To find a package, Java needs two things – the CLASSPATH variable and the name of the package. The CLASSPATH variable is an environmental variable that gives the base location to find packages.

Path Names A path name is list of (nested) directories that is used to locate files. In Unix, we use the forward slash “/” to separate the directories, and in Windows, the backward slash, “\”. Unix: /libraries/newlibraries/utilities/numericstuff In Windows: \libraries\newlibraries\utilities\numericstuff