ITEC 120 2008spring ibarland, jdymacek

home—info—exams—lectures—labs—hws
Recipe—Laws—lies—syntax—java.lang docs—java.util docs

lab02b
Spies and MCs
Javadoc; Strings

Today we'll experiment with Strings -- Strings represent text. This is a third type of data, in addition to int and double.

Experimenting on Strings

Start up a new BlueJ project, named something like “lab02b”. In the code pad (the lower-right corner of the main screen¹), type in some sample strings, such as:

1. "hello"
2. "Don't forget the quotation marks, else Java won't know it's a String."
3. "!&$^%, and &*(# too!"
4. ""
Things get a bit more interesting if we use + to concatenate two Strings:
5. "hi" + "there"
6. "Ja" + "va a la" + "ng" + "u" + "age."

7. Exercise: together as a class, we'll complete the following function, using + for Strings:

   /** Return the sound of an echo, of a given phrase. * * @param _____ The phrase to shout at a cliff-side. * @return The sound returned * * Examples, presuming that `mc` is an instance of Emcee: * mc.echo2( "hello" ) = "hello, hello." * mc.echo2( "Who's there?" ) = "Who's there?, Who's there?." * mc.echo2( "z" ) = ______ * mc.echo2( "" ) = ______ */ _____ echo2( _____ _____ ) { return ____________________________; }

Today's task

• Preliminary: Make a new class Emcee; as before, take the file which BlueJ provides (with a few boilerplate definitions) and gut it out, replacing it with a single class definition, perhaps

  class Emcee { // (We will add all our functions inside the class's curly-braces.) }

• Write a method which, given any name, will return an introduction for that name. That is:

  /** Give a string suitable for introducing a certain name. * * @param name The name of the person being introduced. * @return a mundane introduction. * * Examples (if mcJo were an instance of class Emcee): * mcJo.introduce( "Snowball III" ) = "Hello, world; my name is Snowball III." * mcJo.introduce( "007" ) = "Hello, world; my name is 007." * mcJo.introduce( ____ ) = ______________________________ * mcJo.introduce( "" ) = "Hello, world; my name is ." */ // Put signature here. (See the above javadoc, for the parameter name.)

  The standard steps of approaching a problem:
  1. Test cases. Three are already provided for you; paste those into your code, and write at least one of your own
  2. Write the signature of the function: remember the mantra for declaring a function, “returnType-functionName-openParen-paramName&type”
  3. Javadoc comments. Explain the meaning of each parameter, and what is returned. (Sometimes these will be provided for you; if not then you'll need to write them.)
  4. Finally, fill in the body of the function (return-expression-semicolon).
  5. Test your function by calling the actual test cases written above.

     reminder:

     Put String literals in quotes:

     jo.echo2( "hello" )

     not

     jo.echo2( hello ) /* error -- cannot find variable hello */

     Test introduce by creating an instance of class Emcee (by right-clicking on the tan class-definition-box). Name it, say, “mcJo” (or whatever you like). Then, call your functions in two different ways:
     • Call using BlueJ's menus: right-click on the red instance mcJo. BlueJ then lets you type in a String between the parentheses. Again, be sure to include quotation marks, so that Java knows you are talking about a String.
     • Call using actual code, from BlueJ's Code Pad. Use the mantra “object dot methodName openParen argument”.

• Aside: A function with two inputs: example

  Today we'll write a function which takes in two inputs. It's not a big deal, but we technically haven't mentioned it in Lecture. Here's an example of a function taking two inputs:

  /** Return the cost of ordering several pizzas of a given size. * @param numPizzas THe number of pizzas ordered. * @param size The size (diameter) of the pizzas ordered, in inches. * @return The total price of the order, dollars. * Examples: * ps.costOfMany( 1, 16 ) =~ 6.03 * ps.costOfMany( 3, 16 ) =~ 18.09 * ps.costOfMany( 0, 16 ) = 0 * ps.costOfMany( 7, 0 ) = 0 */ double costOfMany( int numPizzas, double size ) { return numPizzas * this.pizzaArea(size) * 0.03; // 0.03 is the price per square inch of pizza, in dollars. // Note that the price may change, in the future. }

  Note that in the comments, we have two lines beginning “@param”, naming our two parameters. For Global thinkers, who want the general rule, here's the syntax for defining simple two-argument functions:

  typereturn namefunction( typeparam1 nameparam1, typeparam2 nameparam2 ) { return expression; }

• Agent 007 is known for his suave introduction²: "Bond... James Bond." Write the function introduceSpy, which creates such a greeting, given a first and last name:

  /** Given a first and last name, figure out a dramatic greeting * (suitable for a spy). * * @param first The first name of the person being introduced. * @param last The last name of the peron being introduced. * @return A dramatic greeting (suitable for a spy) for the given name. * * Test cases: * * mcJo.introduceSpy( "Engelbert", "Humperdinck" ) = "Humperdinck... *Engelbert* Humperdinck." * mcJo.introduceSpy( "Dweezil", "Zappa" ) = ____________________________ * mcJo.introduceSpy( "McLovin", "" ) = ______________ * mcJo.introduceSpy( "", "Feist" ) = ______________ * mcJo.introduceSpy( "", "" ) = ______________ */ _______ introduceSpy( _____ ______, _____ _____ ) { return ________________________________________; }

  Before you start writing code, fill in the suggested test cases, with the desired output, character-for-character correct. Note how the test cases check the empty string. (When you have two inputs, you have more choices -- you can have one or the other or both inputs be degenerate.) Pay careful attention to spaces.

  From the BlueJ project menu, choose Tools > Checkstyle. This will bring up an extra window with warning messages which can help detect errors sooner. For this class, code you turn in should not only compiles and passes the test cases, but also triggers no checkstyle warnings.

  Now, write the body of the function. (Think: How did your test-cases go from the input to the output? What Strings did you need to concatenate (“+”)? Do the same thing, but in terms of your parameters instead of specific strings like “Dweezil” and “Zappa”.)

  We will check this function off (including the test cases).

• Lectroid spies all have the first name John. Write a program introduceLectroidSpy which takes in only one input, a last name, and introduces the spy. Make one additional test case:

  /** Given a Lectroid's last name (their first name is always "John"), * figure out a dramatic greeting (suitable for a spy). * * @param _____ The last name of the Lectroid. * @return A dramatic greeting (suitable for a spy) for the given Lectroid name. * * Test cases: * introduceLectroidSpy( "Parker" ) = "Parker... *John* Parker." * introduceLectroidSpy( "Z" ) = _________ */ // After test cases, write the signature here.

  • Complete the test case.
  • Write the signature (immediately following the comment), along with a dummy/stub “return "lalala";”.
    You can make sure your program compiles.
  • Now, write the function body.
    Remember the First Law of Programming -- avoid repeated code!
    (Imagine that we wanted to change all introductions so that they used "_" instead of "*", or some fancy html markup tag instead of "*". This should require changing introduceSpy, but should require no further change to introduceLectroidSpy.
• Test your method.

Challenge problem (optional)

Some people wonder, how Bond's standard introduction can be modified for people with three names — say, Lewis Scooter Libby.

• There are two easy approaches:

  • You might say “Libby -- *Lewis Scooter* Libby” (as if the middle name were considered part of the first name—“left-associative”).
  • Or, you might say “Scooter Libby -- *Lewis* Scooter Libby” (as if the middle name were considered part of the last name—“right-associative”).
  Choose the approach you prefer, and write a function introduceSpy3, which takes three inputs (first name, middle name, last name), and returns your preferred variant of the answer.

  Remember, don't repeat code!; your solution should not have (for example) an asterisk character anywhere, since that was already up in introduceSpy. This is a tougher problem, but by working through a couple of test cases by hand you should be able to solve it.

• Some people don't like either of the two variants just mentioned -- because when giving just the (say) “Lewis Scooter” part of their name they could again make that yet more dramatic by saying “Scooter -- *Lewis* Scooter”, as a sub-part of their entire introduction.

  Evaluate each of the two expressions, but first try to work out for yourself what the answers will be:

  mcJo.introduceSpy( mcJo.introduceSpy( "Lewis", "Scooter" ), "Libby" ) // A left-associative approach mcJo.introduceSpy( "Lewis", mcJo.introduceSpy( "Scooter", "Libby" ) ) // A right-associative approach

  You should get different answers!

  Once you understand what those examples are doing, decide which you like better³ Write a function introduceSpyBaroque3 which gives this ornate (convoluted!) introduction for a spy with three names.

• (Challenge:) Make test cases, showing how to generalize this procedure from two or three names to an entire list of names: Given a list like ["John", "Jacob", "Jingleheimer", "Schmidt", "III", "Jr."], what would the output of a function introduceSpyBaroque be which works by returning a value which:
  • starts with "Jr.",
  • is followed by whatever the baroque introduction of the (slightly shorter list of names) ["John", "Jacob", "Jingleheimer", "Schmidt", "III"] is (surrounded by asterisks),
  • followed by " Jr."
  We can't write the code for this until we (a) learn about Lists, and (b) learn about recursion (since the second step involves solving our entire problem on a slightly shorter list, as a single step of solving the problem on the entire list).
  However, you should be able to write several test cases. Use the list ["a"], the list ["a", "b"] (which should give the same result as introduceSpy("a","b")), the list ["a", "b", "c"] (which should give the same result as introduceSpy3("a","b","c")), and finally the list ["a", "b", "c", "d"].
• Compare the above with an approach whose return value
  • starts with the entire baroque introduction of the (slightly shorter list of names) ["Jacob", "Jingleheimer", "Schmidt", "III", "Jr."],
  • followed by "John" surrounded by asterisks,
  • followed by (again) the entire baroque introduction of ["Jacob", "Jingleheimer", "Schmidt", "III", "Jr."].
  Work on the same four a/b/c/d examples given above. Note that the results of this right-associative version is very different from the left-associative version⁴

home—info—exams—lectures—labs—hws
Recipe—Laws—lies—syntax—java.lang docs—java.util docs

©2008, Ian Barland, Radford University Last modified 2008.Jan.29 (Tue)

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