ITEC 120 2007fall ibarland, jdymacek

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

lab02a
Spies and MCs
Javadoc; Strings

We'll experiment with Strings, which were introduced in lecture yesterday.

Today's project will be done in pairs.

Background: 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.
  }

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

Javadoc

You've (hopefully) noticed in the code presented in class, the function is preceded by comments, and the comments have kinda a funny format, what with those “@” signs. The comments are in a special format, called “javadoc”. They explain what the parameters numPizzas and size mean, and what the returned answer means. They help people understand your program, without having to read the bare code.

• The javadoc comment begins with /**, which is one more asterisk than normal comments use.
• The javadoc comment is placed immediately before the function it's describing.
• The first line is a brief summary of the what the function does (which is different from how it does it!)
• The next line tells people what the parameter means: @param followed by the paramter-name followed by a brief description.
• The next line tells people what the function returns; it starts with the special word @param. (Sometimes this is identical to the first javadoc line.)
• After the @return line is an appropriate place to list your test cases.

There is a bonus to writing this information using those tags @param and @return: In BlueJ, look at the code window, and in the upper-right corner change Implementation view (Source Code in BlueJ v2.2.0) to instead ask for the Interface view (Documentation in BlueJ v2.2.0). Voila! Other programmers can look at this web page for pizzaServer, and know how to call our functions, without ever actually having to look at our code!

Reminder: put String literals in quotes

In lecture, we saw functions dealing with Strings. When you call them in BlueJ, be sure to include quotation marks around the letters you want to string together:

jo.echo2( "hello" )

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

Today's task

Preliminary:

• Start up BlueJ.
• Create a new project; a plausible name would be “lab-week2a” or so.
• 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.) }

Experimenting on Strings

Go to BlueJ's code pad in the lower-right corner of the main screen¹. Type in some sample strings, such as:

• "hello"
• "!&$^%, and &*(# too!"
• ""

As just discussed in the lecture yesterday, +, if applied to Strings, will concatenate them. Try these in the Code Pane:

1. "hi" + "there"
2. "Ja" + "va a la" + "ng" + "u" + "age."
3. 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 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.
   4. Finally, fill in the body of the function (return-expression-semicolon).
   5. Test your function by calling the actual test cases written above.
4. 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. 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”.

5. 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:

   /** * ...Add 'param' and 'return' javadoc tags as needed. * * Test cases: * * mcJo.introduceSpy( "Ian", "Barland" ) = "Barland... *Ian* Barland." * mcJo.introduceSpy( "Dweezil", "Zappa" ) = "Zappa... *Dweezil* Zappa." * mcJo.introduceSpy( "Engelbert", "Humperdinck" ) = "Humperdinck... *Engelbert* Humperdinck." * mcJo.introduceSpy( "McLovin", "" ) = ______________ * mcJo.introduceSpy( "", "Feist" ) = ______________ * mcJo.introduceSpy( "", "" ) = ______________ */ _______ introduceSpy( _____ ______, _____ _____ ) { return ________________________________________; }

   Before you start writing code, write two more test cases. What are some degenerate inputs to try? (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.

   We will check this function off (including the test case and the javadoc).

6. 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:

   /** * ... * * 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.
   • Write the javadoc '@param' and '@return' javadoc as needed.
     You can make sure your program compiles, and then select the "Interface" view.
   • 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.
7. 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.

• You might say “Libby -- *Lewis Scooter* Libby”. Or, you might say “Scooter Libby -- *Lewis* Scooter Libby”. Choose the approach you prefer, and write a function introduceSpy3, which takes three inputs (first name, middle name, last name), and gives 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( "Lewis", mcJo.introduceSpy( "Scooter", "Libby" ) ) mcJo.introduceSpy( mcJo.introduceSpy( "Lewis", "Scooter" ), "Libby" ) )

  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.

• (A Challenge problem even for ITEC220:) Given a list of names (like ["John", "Jacob", "Jingleheimer", "Schmidt", "Jr."]), write a function introduceSpyBaroque which
  • starts with "Jr.... ",
  is followed by
  • the baroque introduction of the (slightly shorter list of names) ["Jacob", "Jingleheimer", "Schmidt", "Jr."] surrounded by asterisks,
  followed by
  • " Jr.."
  followed by
  • a period.
  We can't do this problem 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).

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

©2007, Ian Barland, Radford University Last modified 2007.Nov.26 (Mon)

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