ITEC 120 2019fall asbrennem ibarland

home—info—lects—labs—exams—hws
D2L—tutor/PIs—zoom (snow day)
Object120 + its docs—java.lang docs—java.util docs

constructors; named constants
Mysteries Revealed!

• Constructors, for real:

  • Song( String t, String a, double l, boolean c ) { // Java declares a variable named `this` and // initializes it to a new, unfilled object. this.title = t; this.artist = a; this.length = l; this.isCopyrighted = c; }

    We can have whatever code we want inside a constructor; it's just a regular function with that special variable this (and an uninitialized object) created for you. (For example, you might have this.length = l + 3; or if (l < 0) { this.length = 0; } else { this.length = l; }.)
  • The purpose of a constructor: to make sure all fields of an object are initialized.
• Named constants, for real.

  We previously wrote a function with

  static double diskSpaceRequired( Song aSong ) { return aSong.length* 0.0222; }

  However, 0.0222 is a magic number — the code gives the correct answer, but somebody looking at the code and didn't know where the 0.0222 came from could only conclude that we magically chose the correct number from thin air. (In this case, it came from actually measuring some disk-usage for a real iTunes collection; it works out to 1.3MB/min. 1 MB/min is a reasonable estimate to keep in your head.)
  In earlier lectures, we've hinted at giving such constants a name, using ALL_CAPS to indicate that its value is constant -- it doesn't depend whatsoever on the arguments.

  static boolean fitsOnDisk( Song aSong, double freeSpace ) { double MB_PER_SEC = 0.0222; return (aSong.length*MB_PER_SEC);

  Okay, this is better¹. However, really MB_PER_SEC is just a plain ol' local variable as far as Java cares (despite our naming convention). As a local variable, we can only is it inside this particular function. What if we have three other functions dealing with mp3 files that also want access to the name constant?

  Solution: Make the named constant a field — but a static final field!

  class Song extends Object120 { // fields: String title; String artist; double length; boolean isCopyrighted; // a static field: static final double MB_PER_SEC = 0.0222; // N.B. You *must* declare and init a static field on the same line! … static boolean fitsOnDisk( Song aSong, double freeSpace ) { if (aSong.length * MB_PER_SEC <= freeSpace) { … } }

  Now we can use that same constant anywhere inside class Song (and even elsewhere, via Song.MB_PER_SEC). Kinda like a non-local variable!

  So: what do the adjectives static final mean?
  

  • final means "this will never change". (We'll see soon, that regular fields can change.)
  • A static field is associated with the class, and not with individual objects.
    (Display/demo using BlueJ: make two objects and inspect them, and right-click on the class and choose 'inspect'.)

  So if we create fifty Songs (by calling the constructor fifty times), then we'll have fifty different fields named title — but we'll only have one field named MB_PER_SEC since it's static.
  In fact, even if we have zero Songs (because we haven't yet called the Song constructor), we'll still have exactly one field named MB_PER_SEC.

  (This is also true of static functions: a non-static function is associated with a particular object. That's called object-oriented programming, and we'll start doing that next week. But for now, we'll keep all our functions static, and even though we're using objects we're not yet doing actual object-oriented programming.)

• Btw: Other classes:
  • String is actually a class; it's treated a bit specially in Java: when your program mentions (say) "hello", that's actually² turned in to new String("hello"). We can double-click on the small red box in BlueJ to see its fields! (Note: they're private. We'll soon learn about both arrays, and objects-whose-fields-are-other-objects. The field of type char[] is particularly interesting; the square-brackets means it's an array: it has fields whose names are numbers! (indices))
  • We've seen that int is a primitive type, not an object at all. However, there are times when you want to treat an int as if it were an object³. there is a class Integer, which wraps around a single int.

    new Integer(17) // create an object of the 'wrapper' class Integer.

    Similarly, there is a wrapper class Double corresponding to primitive doubles: new Double(23.4).
• Other named constants: There are named constants that exist in built-in classes:

  Math.PI Integer.MAX_VALUE Double.POSITIVE_INFINITY

  You can look up the documentation to find others!
• Javadoc:
  • A comment that starts with /** (So it has become block-comment already after two characters; java itself doesn't care about third character (since it's inside a comment).)
  • Place such a comment immeidately before the thing it describes (field, or method, or class).
  • For each function, there are three parts you need. They describe what the inputs mean, and what does the result mean?
    • A description of what the function does. Keep it concise. (This will often be virtually identical to the hw assignment.)
    • For each parameter: @param paramName What-the-param-means.
    • Once per function: @return What-the-return-value-means.
      This is often the same as the description.
    Include units as appropriate, and you are encouraged to mention other parameters by name. For example:

    /** Return an estimate of the space required to store the mp3 for a Song. * @param myTune The song to estimate the size of. * @return an estimate of the space required to store the mp3 for a `myTune`, in MB. */ static double diskSpaceUsed( Song myTune ) { return myTune.length * 0.0222; }

    More info at: official Javadoc documentation.

  • Note: the comments should describe what the function does, and not how the function goes about its task. People calling your function don't care about how it works — just what it will return.

• Hand back exam01, and glance at the posted exam01-soln.

home—info—lects—labs—exams—hws
D2L—tutor/PIs—zoom (snow day)
Object120 + its docs—java.lang docs—java.util docs

This page licensed CC-BY 4.0 Ian Barland Page last generated

Please mail any suggestions (incl. typos, broken links) to ibarlandradford.edu