ITEC 120 2010fall ibarland

home—info—lects—labs—exams—hws
tutor/PIs—Object120 + its docs—java.lang docs—java.util docs

lect08b
equals, toString;

Notes:

• (new BlueJ version 3.03)
• (drop deadline is Friday)
• Note that if we have a java.utilScanner s, we can of course call s.next() any place that a (String) expression is allowed. For example: new Song( s.next(), s.next(), s.nextDouble(), false )
• Also note that when we make object-oriented calls on fields, it follows the same rules (move the first argument in front of a dot), but it can look confusing because several different dots are going on (accessing a field, and calling a method¹):

  // static version: if ((length(s1.title) > length(s2.title)) … // object-oriented version: if (s1.title.length() > s2.title.length()) …

  Exercise: given a Song s1, how would you get the first half of the artist's name?

  Challenge: given two Songs s1,s2, get the blend of the artist's names: the first half of the first artist name combined with the second half of the second artist's name.

Review hw05-soln-Student.java.

• static void recordGrade( Student stu, char grade, int hrs ) { int updatedCredits = stu.creditHours + hrs; stu.creditHours = updatedCredits; ⋮ }

  Those two lines are usually condensed into: stu.creditHours = stu.creditHours + hrs;. Remember, pronounce Java's “=” as “gets”, because it sure don't mean “equals”!

• Minor thing: we wrote on the board that we want to convert

  input gr	(int)gr	desired
  'A'	65	4
  'B'	66	3
  'C'	67	2
  'D'	68	1
  'F'	70	0

  How to do this? One way is an if-else-if. But with a small bit of cleverness, we see that when the integer-code increases by one, our desired value decreases by one. Or, as the input increases by one, our desired value increases by -1. That sounds like multiplying our input by -1! Then we just need to offset: 69-(int)gr gives us exactly what we want.

  One disadvantage of this is that 69 seems like a magic number -- looking at the code, that number makes us pass our test cases like magic! You could name the constant, though it's not clear what a meaningful name we'd give it. A better solution is to realize that we're doing two things: first determining which letter of the alphabet we have ('A' as 0, 'B' as 1, ...), and then converting that to a gradepoint:

  4 - ((int)gr - (int)'A')

Equality:

• intensional (deep) (“equals(Object)”;
• extensional (shallow) (“==”).

Review: When comparing two object references, == returns true if (and only if) they reference (point to) the identically-same object.

What `equals` means: If you don't do anything to say otherwise, your own classes have a equals (inherited from java.lang.Object) which just does the same thing == does (?!):

// Inside class java.lang.Object, deep in the bowels of Java: public boolean equals(Object that) { return this == that; }

If you want equals to do something smarter, you have to write it yourself (“overriding the version inherited from Object”). That's what class String does, which is why equals works for Strings.

  Robot r1, r2, r3, r4;
  r1 = new Robot("cell phone",true,true);
  r2 = new Robot("cell phone",true,true);
  r3 = r2;
  r4 = r2.evilCopy();

three things extending Object120 gave us:

• constructor (but we have already seen how to make our own)
• toString.
  When not using Object120, we'll need to write our own version (similar to what we did for Treasure) — but we'll call it toString and we must declare it public, so that it can be called from other classes (like the Code Pad, or moreover built-in pre-existing Java classes).
  Task: Write toString for Robots.

• Deeper equality-testing:
  When not using Object120, we'll need to write our own version (similar to what we did for Treasure) — but we'll call it equals and we must declare it public, so that it can be called from other classes (like the Code Pad, or moreover built-in pre-existing Java classes).

  Task: Write equals for Robots.

  Actually, for equals, the true story is a more complicated: we'll defer² it until ITEC220.

  // Inside class Robot:
  public boolean equals(Object that) {
    if (that == null || that.class != this.class) {
      return false;
    }
    else {
      // Now, compare each field of `this` and `that`
      ⋮
    }
  }
      

home—info—lects—labs—exams—hws
tutor/PIs—Object120 + its docs—java.lang docs—java.util docs

©2010, Ian Barland, Radford University Last modified 2010.Oct.21 (Thu)

Please mail any suggestions (incl. typos, broken links) to iba�rlandrad�ford.edu