Primitive types and reference types

• A variable may have one of Java's primitive types:
  • these are types that are built into the language
    int, double, boolean (and long, short, byte, char, float)
  • these variables hold values that have direct machine representations
• Or, a variable may have a reference type:
  • with one exception, they are not built into the language: each class that a programmer defines gives us one such type, e.g.
    String, Scanner, Random, Dog,...
  • the one that is built-in is arrays
  • to create a 'value' belonging to a reference type, you use new (except when exploiting the short-cut for String)
  • variables of these types hold either null or references to objects (i.e. 'pointers' or memory addresses)

They hold different kinds of things

• Primitive type variables:

  int daysInWeek = 7;
  double pi = 3.142;

  
• Reference type variables:

  String s1 = null;
  Dog d1 = null;
  String s2 = "Hi";
  Dog d2 = new Dog("Nobby", 3, "Norfolk Long Pig");

  
• Q: In fact, the last diagram is simplified. In what way?

Arrays

• Arrays are the only built-in reference types
• So array variables hold null or a reference ('pointer'):

  int dailySunshine = null;
  int[] dailyRainfall = new int[7];

  

Arrays of reference types

Dog[] my_sled_team = null;

my_sled_team = new Dog[3];

my_sled_team[0] = new Dog("Charles", 2, "Charlywawa");
my_sled_team[1] = new Dog("Charlene", 7, "Charlywawa");

Printing the contents of a variable

• If there were no toString method, the following would display a long hexadecimal number:

  Dog d = new Dog("Nobby", 3, "Norfolk Long Pig");
  System.out.println(d);

  Q: What is this number?
• So it's a good idea to include a toString method in every class definition (like we did in Dog and Card), e.g.

  public String toString() {
      return name + " is a " + age + " year old " + breed;
  }

• print and println call toString. So these are equivalent:

  System.out.println(d.toString());
  System.out.println(d);

Assignment copies contents

int x = 10;
int y = x;

– x contains 10, so a copy of this value is put into y

Dog myDog = new Dog("Nobby", 3, "Norfolk Long Pig");
Dog yourDog = myDog;

– myDog contains a reference, so a copy of this reference is put into yourDog, giving two references to the same object (not two objects)

Consequences

• Mostly this causes no problems. But sometimes it does...
• E.g. your sled team contains three six-year old Darth Vaders called Tic, Tac and Toe.
• You decide to create it this way:

  Dog[] team = new Dog[3];
  team[0] = new Dog("Tic", 6, "Darth Vader");
  team[1] = team[0];
  team[2] = team[0];
  team[1].setName("Tac");
  team[2].setName("Toe");

  instead of this way:

  Dog[] team = new Dog[3];
  team[0] = new Dog("Tic", 6, "Darth Vader");
  team[1] = new Dog("Tac", 6, "Darth Vader");
  team[2] = new Dog("Toe", 6, "Darth Vader");

• Q: Why is the former wrong?
• We will see that many class definitions contain a clone method, specially designed to copy objects in a proper way

Equality testing using == compares contents

int x = 10;
int y = x;
int z = 10;
if (x == y) {
    System.out.println("Yes, x == y");
}
if (x == z ) {
    System.out.println("Yes, x == z");
}

String s1 = "Hi";
String s2 = s1;
String s3 = "Hi";
String s4 = new String("Hi");
if (s1 == s2) {
    System.out.println("Yes, s1 == s2");
}
if (s1 == s3) {
    System.out.println("Yes, s1 == s3");
}
if (s1 == s4) {
    System.out.println("Yes, s1 == s4");
}

Dog d1 = new Dog("Nobby", 3, "Norfolk Long Pig");
Dog d2 = d1;
Dog d3 = new Dog("Nobby", 3, "Norfolk Long Pig");
if (d1 == d2) {
    System.out.println("Yes, d1 == d2");
}
if (d1 == d3) {
    System.out.println("Yes, d1 == d3");
}

Using a method instead of ==

• Since == doesn't do what we want/expect, the interface of the Java String class definition includes an equals method
• So don't write this:

  if (s1 == s2) ...

  which is true if s1 and s2 contain references to the same String object
• Write this instead:

  if (s1.equals(s2)) ...

  which returns true if s1 and s2 refer to String objects that contain the same characters

Defining an equals method

• Similarly, for any classes you define yourself (e.g. Dog, Card,...) include an equals method so that you can then write

  if (d1.equals(d2)) ...

• Here's what the method might look like for Dog (proper explanation later in the module):

  public boolean equals(Object obj) {
      if (this == obj) {
          return true;
      } else if (obj == null || getClass() != obj.getClass()) {
          return false;
      }
      Dog d = (Dog) obj;
      return (name.equals(d.name) && age == d.age && breed.equals(d.breed));
  }

Summary

Primitive types	Reference types
Examples
int, double, boolean	arrays, String, Scanner, Dog
Contents
Contains a value	Contains null or a reference ('pointer') to an object
System.out.println(...)
Displays the value	Runs toString. By default, toString displays the pointer. But you can supply your own definition to display something more meaningful
Assignment
Copies the value	Copies the reference (hence two pointers to the same object)
Equality testing
== tests for equal values	== tests for equal references (pointing to the same object define your own equals method to compare the objects' instance variables
Passing a parameter to a method
Copies the value, so changes made in the method do not affect the original	Copies the reference (hence two pointers to the same object), so changes to the object made in the method do affect the original

Advanced stuff: Python

• Python does not distinguish primitive types and reference types
• In Python, everything is an object

  x = None
  y = 3
  z = "Hi"

  
• You might like to investigate the difference between == and is in Python

Java's wrapper classes

• For reasons we'll come to later, sometimes you want to treat primitive values as objects
• For this, Java provides wrapper classes: they turn values into objects, e.g.:

  int x = 3;
  Integer y = new Integer(3);

  
• Similarly for Double and Boolean (and Long, Short, Byte, Character and Float)