ITEC 120 2009spring ibarland nokie jmdymacek

home—info—lects—labs—exams—hws
textbook—tutor/PIs—java.lang docs—java.util docs

lect02b
evaluating expressions
and using JOptionPane to get input

Our examples will use based on:

String msg;
msg = "hello";

     +-----------+
msg  |           |
     +-----------+

     +-----------+
msg  |  "hello"  |
     +-----------+

Evaluation an Expression, step-by-step

Okay, let's consider an example where we use the result of a method call as an input to another method call:

Math.sqrt( Math.sqrt(16) )   
// =>
Math.sqrt( 4.0 )
// =>
2.0

Math.sqrt( msg.length() )
//  =>
Math.sqrt( 5 )
//  =>
2.23606797749979 

Sometimes, Java does automatic conversions for us. Consider println, which must be given a String (and doesn't return an answer at all — it's a void method).

System.out.println( msg.length() );
//   =>       
System.out.println( 5 );
// This is a bit problematic, since we are passing an int to println,
// but really it wants a String.
// It turns out, Java is inserting a method call for us1:
//   =>
System.out.println( Integer.toString(5) );
// =>
System.out.println( "5" );
// =>
// void     [no answer, although some screen-pixels got painted.]

Question: Why is the following non-sensical?:

(System.out.println( msg )).length()

The truth about variables

• We've said that whenever you use a variable msg, Java really goes and fetches the value stored in the box labeled msg.
• The syntax for method-call is “object.methodName(args…)”, and yet we have always used a variable in front of the dot. (Gee, maybe our syntax should actually be “variable.methodName…”?)

Math.sqrt( msg.length() )
//  =>
Math.sqrt( "hello".length() )
//  =>
Math.sqrt( 5 )
//  =>
2.23606797749979 

System.out.println( Integer.toString(msg.length()) );
// =>
System.out.println( Integer.toString("hello".length()) );
//   =>       
System.out.println( Integer.toString(5) );
//   =>       
System.out.println( "5" );
// =>
// void     [no answer, although some screen-pixels got painted.]

We can also call a method, and then take the result and call another method:

(msg.toUpperCase()).charAt(3)

String msgShouted;
msgShouted = msg.toUpperCase();

msgShouted.charAt(3)

JOptionPane

javax.swing.JOptionPane is (the rather unwieldy) name of an object that knows how to put up dialog-boxes. In particular:

javax.swing.JOptionPane.showInputDialog( "What is your name?" )

Most commonly, you want to remember the result for future use:

String theUsersName;
theUsersName = javax.swing.JOptionPane.showInputDialog( "What is your name?" );

javax.swing.JOptionPane.showInputDialog( "What is your name?" ).toUpperCase()

converting Strings into numbers

JOptionPane's showInputDialog is a nice method, but it only returns a String.

javax.swing.JOptionPane.showInputDialog( "How old are you?" )
// [after some typing from the user:] =>
"43"

It turns out, if you scour the documentation, that there are two useful methods: Integer.parseInt, and Double.parsedouble. For example:

Integer.parseInt( "23" ) 
// =>
23

Double.parseDouble( "-23.45e3" ) 
// =>
-23450.0 

Aside: Difference in book terminology:

In lecture, we use the term “argument” to mean the actual value given to a method (like 5 or "hello"), and the term “parameter” will mean the name which the method gives to its argument (like x or frameNum).

In the book, Horstmann uses the term “parameter” to mean both these concepts. I find this a bit confusing, myself, since they really are distinct concepts. The terms “actual parameter” and “formal parameter” are also used for our “argument” and “parameter” respectively.

System.out.println( msg.length() );

System.out.println( Integer.toString(msg.length()) );

home—info—lects—labs—exams—hws
textbook—tutor/PIs—java.lang docs—java.util docs

©2009, Ian Barland, Radford University Last modified 2009.Feb.24 (Tue)

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