Basic Java Syntax

• Primitive types
• Arithmetic, logical, and relational operators
• Conditional expressions and loops
• Mathematical methods
• Keyboard input and console output
• Execution of local non-Java programs
• References
• Strings
• Arrays
• Vectors
• Simple example of building a binary tree
• Exceptions

Rules of Syntax

/* Block style comments. These may span multiple
   lines. They may not be nested. */

// Single-line comment

while (int i=1; i<=5; i++) {
  if (i==2)
    System.out.println("Tea for two.");
  else
    System.out.println("Not two.");
}

while(int i=1;i<=5;i++){if(i==2)
System.out.println("Tea for two.");else
System.out.println("Not two.");}

Primitive Types

boolean This is a type with only two possible values: true and false. A boolean is an actual type, not merely a disguised int. For example:

boolean flag1 = false;
boolean flag2 = (6 < 7); // true
boolean flag3 = !true;   // false
boolean flag4 = 0;       // compiler error!

char This is a 16-bit unsigned integer value representing a Unicode character. You can specify values numerically or with a character enclosed inside single quotes. These characters can be keyboard chars, unicode escape chars (\uxxxx with x in hex), or one of the special escape sequences \b(backspace), \t (tab), \n (newline), \f (form feed), \r (carriage return), \" (double quote), \' (single quote), or \\ (backslash). For instance:

char c0= 3;
char c1 = 'Q';
char c2 = '\u0000'; // Smallest value
char c3 = '\uFFFF'; // Biggest value
char c4 = '\b';     // Backspace

Learn more about the Unicode standard at http://www.unicode.org/.

byte This is an 8-bit, signed, two's-complement integer. See the description of int for ways to represent integral values. Bytes can range in value from-128 to +127.

short This is a 16-bit, signed, two's-complement integer. See the description of int for ways to represent integral values. Shorts range in value from-32768 to +32767.

int This is a 32-bit, signed, two's-complement integer. You can specify integer constants in base 10 (1, 10, and 100 for 1, 10, and 100, respectively), octal with a prefix of 0 (01, 012, 0144 for 1, 10, and 100), or hex by using a prefix of 0x (0x1, 0xA, 0x64 for 1, 10, and 100). For hexadecimal numbers, you can use uppercase or lowercase for x, A, B, C, D, E, and F. Ints range from Integer.MIN_VALUE (-2³¹) to Integer.MAX_VALUE(2³¹ - 1). For example:

int i0 = 0;
int i1 = -12345;
int i2 = 0xCafeBabe; // Magic number of .class files
int i3 = 0777;       // Octal number, 511 in decimal

long This is a 64-bit, signed, two's-complement integer. Use a trailing L for literals. A lowercase l is also legal to designate a long literal, but discouraged. Depending on the display font, the lowercase l can be confused with a numerical 1 (one). You can use base 10, 8, or 16 for values. Longs range from Long.MIN_VALUE (-2⁶³) to Long.MAX_VALUE (2⁶³ - 1). Some examples:

long a0 = 0L;
long a1 = -12345l;
long a2 = 0xBabeL; // Tower of Babel?
long a3 = -06767l;

Except for char, the integral types (byte, char, short, int, and long) are signed values. There is no built-in support for unsigned integer values in Java as in the C or C++ programming languages. When using integral types, especially smaller types such as byte or short, you should ensure that the numbers you wish to represent do not exceed the representable range of the primitive type. For example, if you want to represent the day of the year, you cannot use a byte, because it can only store a number as large as 127. Instead, you need to use a short, int, or long. Anint is probably sufficient for most applications.

float This is a 32-bit, IEEE 754 floating-point number. You must use a trailing f or F to distinguish single precision floating-point literals. In the example below, the f is required or else the compiler interprets the constant as a double precision floating-point number that needs a cast before being assigned to a float:

float f0 = -1.23f;

You can also use an e or E to indicate an exponent (power of 10). For instance, the first expression below assigns the value 6.02 x10²³ to the variablef1 while the second gives the value 4.5 x 10^-17 to f2.

float f1 = 6.02E23F;
float f2 = 4.5e-17f;

Floats range from Float.MIN_VALUE (1.4 x 10^-45) to Float.MAX_VALUE (3.4 x 10³⁸). Floating-point arithmetic never generates an exception, even in divide-by-zero cases. The Float class defines the constants POSITIVE_INFINITY, NEGATIVE_INFINITY, and NaN (not-a-number) to use for some of these special cases. Use Float.isNaN to compare to NaN because (Float.NaN == Float.NaN) returns false, in conformance with the IEEE specification, which states that all comparisons to NaNs should fail.

double This is a 64-bit, IEEE 754 floating-point number. You are allowed to append a trailing d or D, but it is normally omitted. Some examples:

double d0 = 1.23;
double d2 = -4.56d;
double d3 = 6.02214E+23;
double d4 = 1e-99;

Doubles range from Double.MIN_VALUE (4.9 x 10^-324) to Double.MAX_VALUE (1.7 x 10³⁰⁸). As with float, double-precision arithmetic never generates an exception. To handle unusual situations, the Double class also defines fields named POSITIVE_INFINITY,NEGATIVE_INFINITY, and NaN. Use Double.isNaN to compare a double to Double.NaN.

Primitive-Type Conversion

Type2 type2Var = (Type2)type1Var;

int i = 3;
byte b = (byte)i; // Cast i to a byte; no effect
long x = 123456L;
short s = (short)x; // Cast x to a short; lossy

double d = 3.1416;
float f = (float)d; // Cast from 64 to 32 bits
short s = (short)f; // Cast a float to a short
int i = s; // Upward conversion, no cast is required

Operators, Conditionals, Iteration

Point p1(3,4), p2(1,3); // C++ constructor syntax
p1 += p2; // To translate point p1 by p2

p1.translate(p2);

Arithmetic Operators

x = y + 5;

int x = 3, y = 2;
int z = x / y; // 1

int i = 1, j = 1;
int x = i++; // x=1, i=2
int y = ++j; // y=2, j=2

int x = 3;
int y = x << 2; // 12

int x = ~127; // -128

int x = 127 & 2; // 2
int y = 127 | 2; // 127
int z = 127 ^ 2; // 125

var op= val;

var = var op val;

i = i + 5;
x = x * 3;

i += 5;
x *= 3;

Conditionals

if (boolean-expression) {
  statement;
}
if (boolean-expression) {
  statement1;
} else {
  statement2;
}

boolean-expression ? val1 : val2;

switch(someInt) {
  case val1: statement1;
             break;
  case val2: statement2a;
             statement2b;
             break;
  ...
  default: statementN;
}

if (boolean-expression) statement

if (boolean-expression) statement1 else statement2

The if keyword expects a boolean expression in parentheses. If the expression evaluates to true, the subsequent statement is executed. If the expression is false, the else statement (if present) is executed. Supplying a non-boolean expression results in a compile-time error, unlike the case with C and C++, which treat anything not equal to zero as true. Here is an example that returns the larger of two integers:

// See Math.max
public static int max2(int n1, int n2) {
  if (n1 >= n2)
    return(n1);
  else
    return(n2);
}

You can combine multiple statements in the if-else clause by enclosing them in curly braces. For instance:

public static int max2Verbose(int n1, int n2) {
  if (n1 >= n2) {
    System.out.println(n1 + " is larger.");
    return(n1);
  } else {
    System.out.println(n2 + " is larger.");
    return(n2);
  }
}

Next, note that an else always goes with the most recent preceding if that does not already have a matching else. For example:

public static int max3(int n1, int n2, int n3) {
  if (n1 >= n2)
    if (n1 >= n3)
      return(n1);
    else
      return(n3);
  else
    if (n2 >= n3)
      return(n2);
    else
      return(n3);
}

Two more points should be made here. First of all, note that the nested (indented) if statements are considered single statements; thus, curly braces are not required even though the statements flow over several lines. More importantly, see how indentation makes the association of the else clauses clearer.

Several different indentation styles are consistent with this approach. Following are a few of the most popular; we use the first style throughout most of the book.

// Indentation Style 1
public SomeType someMethod(...) {
  if {
    statement1;
    ....
    statementN
  } else {
    statementA;
    ...
    statementZ;
  }
}

// Indentation Style 2
public SomeType someMethod(...)
{ if
  { statement1;
    ...
    statementN;
  } else
  { statementA;
    ...
    statementZ;
  }
}

// Indentation Style 3
public SomeType someMethod(...)
{
  if
  {
    statement1;
    ...
    statementN;
  }
  else
  {
    statementA;
    ...
    statementZ;
  }
}

In certain cases, you can simplify multiple comparisons by combining them using logical operators && (logical AND) or || (logical OR). As in C and C++, these operators perform "short circuit" evaluation, which means that they return an answer as soon as they have enough information to do so (even if all the subexpressions have not been evaluated). In particular, a comparison with && evaluates to false whenever the leftmost conjunct isfalse; the right side is not then evaluated. Likewise, an expression with || immediately evaluates as true if the leftmost disjunct is true. Here's an example:

public static int max3(int n1, int n2, int n3) {
  if ((n1 >= n2) && (n1 >= n3))
    return(n1);
  else if ((n2 >= n1) && (n2 >= n3))
    return(n2);
  else
    return(n3);
}

There are single character forms of the logical operators, & and |, that do evaluate all of their operands. However, they are rarely used and may be confused with the bitwise arithmetic operators.

boolean-expression ? thenValue : elseValue

Since if statements do not return a value, Java provides a shortcut when the purpose of the if is to assign to a single variable. For example, you can express the following four lines

if (someCondition)
  someVar = value1;
else
  someVar = value2;

more simply as

someVar = (someCondition ? value1 : value2);

In fact, you can use this form whenever you need to return a value, although overuse can make code difficult to read. Here is a variation of max2 that uses it:

public static int max2Short(int n1, int n2) {
  return((n1 >= n2) ? n1 : n2);
}

switch(integralExpression) { switchBody }

The switch construct provides a compact way to compare an expression to a variety of integer types (char, byte, short, or int, but not long). The idea is to supply an integer expression and then provide, inside the switch body, one or more case statements that designate different possible values of the expression. When one matches, it and all subsequent cases are executed. Here is an example that uses switch to generate the string representation of a single-digit integer:

public static String number(int digit) {
  switch(digit) {
    case 0: return("zero");
    case 1: return("one");
    case 2: return("two");
    case 3: return("three");
    case 4: return("four");
    case 5: return("five");
    case 6: return("six");
    case 7: return("seven");
    case 8: return("eight");
    case 9: return("nine");
    default: return("Not a single digit");
  }
}

Section 8.9 (Arrays) describes a simpler way to perform this integer-to-string conversion by using arrays. The most confusing thing about switchstatements is that code "falls through" cases; all statements after the first matching case are executed. This is handy in some situations because it lets you combine cases, as follows:

switch(val) {
  case test1:
  case test2:
    actionForTest1and2();
  ...
}

However, it can catch you by surprise if the case statements do not contain an explicit return or break. For example, consider the following verbose variation of the number method:

// Incorrect version that forgets about case
// fall-through.

public static String numberVerbose(int digit) {
  String result;
  switch(digit) {
    case 0:  System.out.println("zero");
             result = "zero";
    case 1:  System.out.println("one");
             result = "one";
    case 2:  System.out.println("two");
             result = "two";
    case 3:  System.out.println("three");
             result = "three";
    case 4:  System.out.println("four");
             result = "four";
    case 5:  System.out.println("five");
             result = "five";
    case 6:  System.out.println("six");
             result = "six";
    case 7:  System.out.println("seven");
             result = "seven";
    case 8:  System.out.println("eight");
             result = "eight";
    case 9:  System.out.println("nine");
             result = "nine";
    default: System.out.println(
               "Not a single digit");
             result = "Not a single digit";
  }
  return(result);
}

Because there is no explicit direction to exit the switch after the first match, multiple cases are executed. For instance, here is the output whennumberVerbose(5) is called:

five
six
seven
eight
nine
Not a single digit

The standard solution is to use the break statement to exit the switch after the first match, as in the following corrected version:

public static String numberVerboseFixed(int digit) {
  String result;
  switch(digit) {
    case 0: System.out.println("zero");
            result = "zero";
            break;
    case 1: System.out.println("one");
            result = "one";
            break;
    ...
    default: System.out.println("Not a single digit");
             result = "Not a single digit";
  }
  return(result);
}

Loops

while (continueTest) {
  body;
}

do {
  body;
} while (continueTest);

for(init; continueTest; updateOp) {
  body;
}

while loops The while construct tests the supplied boolean continuation test, executing the body as long as the test returns true. For example, the following method prints out the numbers in the range from 0 to max.

public static void listNums1(int max) {
  int i = 0;
  while (i <= max) {
    System.out.println("Number: " + i);
    i++;
  }
}

Executing listNums1(5) results in the following output:

0: zero
1: one
2: two
3: three
4: four

do loops The do construct differs from while in that the test is evaluated after the loop body rather than before. This means that the body will always be executed at least once, regardless of the test's value. Following is a variation of the listNums method, using do. The result of listNums2(5)is identical to that shown for listNums1(5); however, listNums2(-5) would print "Number: 0", while listNums1(-5) would print nothing. The reason is that with a do loop the test is performed after the loop body, whereas a while loop tests before the loop body. In listNums1(-5), the loop body is never entered.

public static void listNums2(int max) {
  int i = 0;
  do {
    System.out.println("Number: " + i);
    i++;
  } while (i <= max); // Don't forget the semicolon
}

Forgetting the final semicolon in a do loop is a common syntax error.

for loops The for construct is by far the most common way to create loops with numbered counters. First, the init part is executed once. Then, as long as the continuation test evaluates to true, the statement is executed and then the update operation is performed. Here's an example that gives the same result as the previous two versions when passed a positive argument.

public static void listNums3(int max) {
  for(int i=0; i<max; i++) {
    System.out.println("Number: " + i);
  }
}

It is also legal to omit any (or all) of the three for clauses. A missing continueTest is treated as true. Thus,

for(;;) { body }

and

while(true) { body }

are equivalent. These forms are occasionally used when the termination test cannot be easily placed in the initial for or while clause. Instead, the body contains a conditional return or break.

DropBall.java

/** Simulating dropping a ball from the top of the Washington
 *  Monument. The program outputs the height of the ball each
 *  second until the ball hits the ground.
 */

public class DropBall {
  public static void main(String[] args) {
    int time = 0;
    double start = 550.0, drop = 0.0;
    double height = start;
    while (height > 0) {
      System.out.println("After " + time +
                   (time==1 ? " second, " : " seconds,") +
                   "the ball is at " + height + " feet.");
      time++;
      drop = freeFall(time);
      height = start - drop;
    }
    System.out.println("Before " + time + " seconds could " +
                       "expire, the ball hit the ground!");
  }

  /** Calculate the distance in feet for an object in
   *  free fall.
   */

  public static double freeFall (float time) {
    // Gravitational constant is 32 feet per second squared
    return(16.0 * time * time); // 1/2 gt^2
  }
}

Output from DropBall

Prompt> java DropBall
After 0 seconds,the ball is at 550.0 feet.
After 1 second, the ball is at 534.0 feet.
After 2 seconds,the ball is at 486.0 feet.
After 3 seconds,the ball is at 406.0 feet.
After 4 seconds,the ball is at 294.0 feet.
After 5 seconds,the ball is at 150.0 feet.
Before 6 seconds could expire, the ball hit the ground!

The Math Class

Constants

public static final double E

This constant is e, the base for natural logarithms, 2.7182818284590452354.

public static final double PI

This constant is p, 3.14159265358979323846.

General-Purpose Methods

public static int abs(int num)

public static long abs(long num)

public static float abs(float num)

public static double abs(double num)

These methods return the absolute value of the specified number.

public static double ceil(double num)

public static double floor(double num)

The ceil method returns a double corresponding to the smallest integer greater than or equal to the specified number; floor returns a doublecorresponding to the largest integer less than or equal to the number.

public static exp(double num)

This method returns e^num.

public static double IEEEremainder(double f1, double f2)

This method returns the remainder of f1 divided by f2, as specified in the IEEE 754 standard.

public static double log(double num)

This method returns the natural logarithm of the specified number. Java does not provide a method for calculating logs in other common bases (e.g., 10 or 2), but following is a method that does this computation, using the relationship:

public static double log(double num, double base) {
  return(Math.log(num) / Math.log(base));
}

public static int max(int num1, int num2)

public static long max(long num1, long num2)

public static float max(float num1, float num2)

public static double max(double num1, double num2)

public static int min(int num1, int num2)

public static long min(long num1, long num2)

public static float min(float num1, float num2)

public static double min(double num1, double num2)

These methods return the bigger (max) or smaller (min) of the two numbers.

public static double pow(double base, double exponent)

The pow method returns base^exponent.

public static double random()

This method returns a random number from 0.0 (inclusive) to 1.0 (exclusive). For more control over random numbers, use thejava.util.Random class.

public static double rint(double num)

public static int round(float num)

public static long round(double num)

These methods round the number toward the nearest integer. They differ in their return types and what they do for a number of the form xxx.5. Theround methods round up in such a case; rint rounds to the nearest even number, as specified in the IEEE 754 standard. Although less intuitive, the behavior of rint avoids skewing sums of rounded numbers upwards.

public static double sqrt(double num)

This method returns  for nonnegative numbers and returns Double.NaN if the input is NaN or is negative.

Trigonometric Methods

public static double sin(double radians)

public static double cos(double radians)

public static double tan(double radians)

These methods return the sine, cosine, and tangent of the specified number, interpreted as an angle in radians.

public static double toDegrees(double radians)

public static double toRadians(double degrees)

These methods perform conversions between angles expressed in radians and degrees. For example, the following computes the sine of 60 degrees:

Math.sin(Math.toRadians(60.0))

public static double acos(double val)

public static double asin(double val)

public static double atan(double val)

These methods return the arc cosine, arc sine, and arc tangent of the specified value. The result is expressed in radians.

public static double atan2(double y, double x)

This method returns the q part of the polar coordinate (r,q) that corresponds to the cartesian coordinate (x,y). This is the atan of y/x that is in the range -p to p

BigInteger and BigDecimal

Factorial.java

import java.math.BigInteger;

/** Computes an exact factorial, using a BigInteger. */

public class Factorial {
  public static void main(String[] args) {
    for(int i=1; i<=256; i*=2) {
      System.out.println(i + "!=" + factorial(i));
    }
  }

  public static BigInteger factorial(int n) {
    if (n <= 1) {
      return(new BigInteger("1"));
    } else {
      BigInteger bigN = new BigInteger(String.valueOf(n));
      return(bigN.multiply(factorial(n - 1)));
    }
  }
}

 Factorial Output

Prompt> java Factorial
1!=1
2!=2
4!=24
8!=40320
16!=20922789888000
32!=263130836933693530167218012160000000
64!=1268869321858841641034333893351614808028655161745451921988018
94375214704230400000000000000
128!=385620482362580421735677065923463640617493109590223590278828
40327637340257516554356068616858850736153403005183305891634759217
29322624988577661149552450393577600346447092792476924955852800000
00000000000000000000000000
256!=857817775342842654119082271681232625157781520279485619859655
65037726945255314758937744029136045140845037588534233658430615719
68346936964753222892884974260256796373325633687864426752076267945
60187968867971521143307702077526646451464709187326100832876325702
81898077367178145417025052301860849531906813825748107025281755945
94769870346657127381392862052347568082188607012036110831520935019
47437109101726968262861606263662435022840944191408424615936000000
000000000000000000000000000000000000000000000000000000000

Input and Output

Printing to Standard Output

System.out.println(
   2 + 'B' + " || ! " + new Integer(2) + "B");

import java.text.*;

/** Formatting real numbers with DecimalFormat. */

public class NumFormat {
  public static void main (String[] args) {
    DecimalFormat science = new DecimalFormat("0.000E0");
    DecimalFormat plain = new DecimalFormat("0.0000");

    for(double d=100.0; d<140.0; d*=1.10) {
      System.out.println("Scientific: " + science.format(d) +
                         " and Plain: " + plain.format(d));
    }
  }
}

NumFormat Output

Prompt> java NumFormat
Scientific: 1.000E2 and Plain: 100.0000
Scientific: 1.100E2 and Plain: 110.0000
Scientific: 1.210E2 and Plain: 121.0000
Scientific: 1.331E2 and Plain: 133.1000

Printing to Standard Error

Reading from Standard Input

BufferedReader keyboard =
  new BufferedReader(
    new InputStreamReader(System.in));

String line = keyboard.readLine();

Execution of Non-Java Programs

1. Get the special Runtime object. Use the static getRuntime method of the Runtime class for this, as follows:

   Runtime rt = Runtime.getRuntime();
   

2. Execute the program. Use the exec method, which returns a Process object, as illustrated below:

   Process proc = rt.exec("someProgram");
   

   This starts the program but does not wait for the program to terminate or print the program results. Note that the exec method does not make use of yourPATH environment variable (used on Windows 98/NT and Unix to identify where to look for programs), so you need to specify the full pathname. Also, execdoes not start a shell, so special shell characters (such as > or | in Unix) will not be recognized. Finally, note that the Runtime class provides versions ofexec that take an array of strings and pass the strings as command-line arguments to a program. For example,

   String[] args = { "-l", "*.java" };
   rt.exec("ls", args); // Directory listing.
   

3. Optional: wait for the program to exit. The exec method returns immediately, regardless of how long it takes the program to run. This behavior enables you to start long-running programs such as Netscape and still continue processing; however, this behavior catches many users off guard. If you want the program to wait until the program exits before returning, use the waitFor method after you start the process:

   proc.waitFor();
   

   While you might simply use exec to start Netscape, you would add waitFor if one program needs to terminate before another can begin. For example, you might call javac on a source file and use java to execute the result, but the compilation must finish before the program can invoke a new instance of the JVM to execute the complied class file. Note that waitFor does not print the program results; it simply waits for the program to finish before returning.
4. Optional: process the results. Rather than simply waiting for the program to terminate, you might want to capture its output. For example, telling the system to do a directory listing is not too useful unless you access the results. You can print the results by attaching a BufferedReader to the process, then reading from it, as in the following example:

   try {
     BufferedReader buffer =
      new BufferedReader(
        new InputStreamReader(proc.getInputStream()));
     String s = null;
     while ((s = buffer.readLine()) != null) {
       System.out.println("Output: " + s);
     }
     buffer.close();
   } catch(Exception e) {
     /* Ignore read errors */
   }
   

 Exec.java

import java.io.*;

/** A class that eases the pain of running external processes
 *  from applications. Lets you run a program three ways:
 *  <OL>
 *     <LI><B>exec</B>: Execute the command, returning
 *         immediately even if the command is still running.
 *         This would be appropriate for printing a file.
 *     <LI><B>execWait</B>: Execute the command, but don't
 *         return until the command finishes. This would be
 *         appropriate for sequential commands where the first
 *         depends on the second having finished (e.g.,
 *         <CODE>javac</CODE> followed by <CODE>java</CODE>).
 *     <LI><B>execPrint</B>: Execute the command and print the
 *          output. This would be appropriate for the Unix
 *          command <CODE>ls</CODE>.
 *  </OL>
 *  Note that the PATH is not taken into account, so you must
 *  specify the <B>full</B> pathname to the command, and shell
 *  built-in commands will not work. For instance, on Unix the
 *  above three examples might look like:
 *  <OL>
 *    <LI><PRE>Exec.exec("/usr/ucb/lpr Some-File");</PRE>
 *    <LI><PRE>Exec.execWait("/usr/local/bin/javac Foo.java");
 *        Exec.execWait("/usr/local/bin/java Foo");</PRE>
 *    <LI><PRE>Exec.execPrint("/usr/bin/ls -al");</PRE>
 *  </OL>
 */
public class Exec {

  private static boolean verbose = true;

  /** Determines if the Exec class should print which commands
    * are being executed, and prints error messages if a problem
    * is found. Default is true.
    *
    * @param verboseFlag true: print messages, false: don't.
    */

  public static void setVerbose(boolean verboseFlag) {
    verbose = verboseFlag;
  }

  /** Will Exec print status messages? */

  public static boolean getVerbose() {
    return(verbose);
  }

  /** Starts a process to execute the command. Returns
    * immediately, even if the new process is still running.
    *
    * @param command The <B>full</B> pathname of the command to
    * be executed. No shell built-ins (e.g., "cd") or shell
    * meta-chars (e.g.">") are allowed.
    * @return false if a problem is known to occur, but since
    * this returns immediately, problems aren't usually found
    * in time. Returns true otherwise.
    */

  public static boolean exec(String command) {
    return(exec(command, false, false));
  }

  /** Starts a process to execute the command. Waits for the
    * process to finish before returning.
    *
    * @param command The <B>full</B> pathname of the command to
    * be executed. No shell built-ins or shell metachars are
    * allowed.
    * @return false if a problem is known to occur, either due
    * to an exception or from the subprocess returning a
    * nonzero value. Returns true otherwise.
    */

  public static boolean execWait(String command) {
    return(exec(command, false, true));
  }

  /** Starts a process to execute the command. Prints any output
    * the command produces.
    *
    * @param command The <B>full</B> pathname of the command to
    * be executed. No shell built-ins or shell meta-chars are
    * allowed.
    * @return false if a problem is known to occur, either due
    * to an exception or from the subprocess returning a
    * nonzero value. Returns true otherwise.
    */

  public static boolean execPrint(String command) {
    return(exec(command, true, false));
  }

  /** This creates a Process object via Runtime.getRuntime.exec()
    * Depending on the flags, it may call waitFor on the process
    * to avoid continuing until the process terminates, and open
    * an input stream from the process to read the results.
    */

  private static boolean exec(String command,
                              boolean printResults,
                              boolean wait) {
    if (verbose) {
      printSeparator();
      System.out.println("Executing '" + command + "'.");
    }
    try {
      // Start running command, returning immediately.
      Process p  = Runtime.getRuntime().exec(command);

      // Print the output. Since we read until there is no more
      // input, this causes us to wait until the process is
      // completed.
      if(printResults) {
        BufferedReader buffer = new BufferedReader(
          new InputStreamReader(p.getInputStream()));
        String s = null;
        try {
          while ((s = buffer.readLine()) != null) {
            System.out.println("Output: " + s);
          }
          buffer.close();
          if (p.exitValue() != 0) {
            if (verbose) {
              printError(command + " - p.exitValue() != 0");
            }
            return(false);
          }
        } catch (Exception e) {
          // Ignore read errors; they mean the process is done.
        }

      // If not printing the results, then we should call waitFor
      // to stop until the process is completed.
      } else if (wait) {
        try {
          System.out.println(" ");
          int returnVal = p.waitFor();
          if (returnVal != 0) {
            if (verbose) {
              printError(command);
            }
            return(false);
          }
        } catch (Exception e) {
          if (verbose) {
            printError(command, e);
          }
          return(false);
        }
      }
    } catch (Exception e) {
      if (verbose) {
        printError(command, e);
      }
      return(false);
    }
    return(true);
  }

  private static void printError(String command,
                                 Exception e) {
    System.out.println("Error doing exec(" + command + "): " +
                        e.getMessage());
    System.out.println("Did you specify the full " +
                       "pathname?");
  }

  private static void printError(String command) {
    System.out.println("Error executing '" + command + "'.");
  }

  private static void printSeparator() {
    System.out.println
      ("==============================================");
  }
}

 ExecTest.java

/** A test of the Exec class. */

public class ExecTest {
  public static void main(String[] args) {
    // Note: no trailing "&" -- special shell chars not
    // understood, since no shell started. Besides, exec
    // doesn't wait, so the program continues along even
    // before Netscape pops up.
    Exec.exec("/usr/local/bin/netscape");

    // Run commands, printing results.
    Exec.execPrint("/usr/bin/ls");
    Exec.execPrint("/usr/bin/cat Test.java");

    // Don't print results, but wait until this finishes.
    Exec.execWait("/usr/java1.3/bin/javac Test.java");

    // Now Test.class should exist.
    Exec.execPrint("/usr/bin/ls");
  }
}

 ExecTest Output

Unix> java ExecTest
==============================================
Executing '/usr/local/bin/netscape'.
==============================================
Executing '/usr/bin/ls'.
Output: Exec.class
Output: Exec.java
Output: ExecTest.class
Output: ExecTest.java
Output: Test.java
==============================================
Executing '/usr/bin/cat Test.java'.
Output: public class Test {
Output:   boolean flag;
Output: }
==============================================
Executing '/usr/java1.3/bin/javac Test.java'.
==============================================
Executing '/usr/bin/ls'.
Output: Exec.class
Output: Exec.java
Output: ExecTest.class
Output: ExecTest.java
Output: Test.class
Output: Test.java

 Reference Types

 ReferenceTest.java

import java.awt.Point;

public class ReferenceTest {
  public static void main(String[] args) {
    Point p1 = new Point(1, 2); // Assign Point to p1
    Point p2 = p1; // p2 is new reference to *same* Point
    print("p1", p1); // (1, 2)
    print("p2", p2); // (1, 2)
    triple(p2); // Doesn't change p2
    print("p2", p2); // (1, 2)
    p2 = triple(p2); // Have p2 point to *new* Point
    print("p2", p2); // (3, 6)
    print("p1", p1); // p1 unchanged: (1, 2)
  }

  public static Point triple(Point p) {
    p = new Point(p.x * 3, p.y * 3); // Redirect p
    return(p);
  }

  public static void print(String name, Point p) {
    System.out.println("Point " + name + "= (" +
                       p.x + ", " + p.y + ").");
  }
}

ReferenceTest Output

Prompt> java ReferenceTest
Point p1= (1, 2).
Point p2= (1, 2).
Point p2= (1, 2).
Point p2= (3, 6).
Point p1= (1, 2).

import java.awt.Point;

public class ModificationTest extends ReferenceTest {
  public static void main(String[] args) {
    Point p1 = new Point(1, 2); // Assign Point to p1
    Point p2 = p1; // p2 is new reference to *same* Point
    print("p1", p1); // (1, 2)
    print("p2", p2); // (1, 2)
    munge(p2); // Changes fields of the *single* Point
    print("p1", p1); // (5, 10)
    print("p2", p2); // (5, 10)
  }

  public static void munge(Point p) {
    p.x = 5;
    p.y = 10;
  }
}

ModificationTest Output

Prompt> java ModificationTest
Point p1= (1, 2).
Point p2= (1, 2).
Point p1= (5, 10).
Point p2= (5, 10).

Java Argument-Passing Conventions

The instanceof Operator

if (item instanceof Breakable) {
  add(item, chinaCabinet);
}

interface Barking {}

class Mammal {}

class Canine extends Mammal {}

class Dog extends Canine implements Barking {}

class Retriever extends Dog {}

public class InstanceOf {
  public static void main(String[] args) {
    Canine wolf = new Canine();
    Retriever rover = new Retriever();

    System.out.println("Testing instanceof:");
    report(wolf, "wolf");
    System.out.println();
    report(rover, "rover");

    System.out.println("\nTesting isInstance:");
    Class barkingClass = Barking.class;
    Class dogClass = Dog.class;
    Class retrieverClass = Retriever.class;
    System.out.println("  Does a retriever bark? " +
                       barkingClass.isInstance(rover));
    System.out.println("  Is a retriever a dog? " +
                       dogClass.isInstance(rover));
    System.out.println("  Is a dog necessarily a retriever? " +
                       retrieverClass.isInstance(new Dog()));
  }

  public static void report(Object object, String name) {
    System.out.println("  " + name + " is a mammal: " +
                       (object instanceof Mammal));
    System.out.println("  " + name + " is a canine: " +
                       (object instanceof Canine));
    System.out.println("  " + name + " is a dog: " +
                       (object instanceof Dog));
    System.out.println("  " + name + " is a retriever: " +
                       (object instanceof Retriever));
  }
}

 InstanceOf Output

prompt> java InstanceOf
Testing instanceof:
  wolf is a mammal: true
  wolf is a canine: true
  wolf is a dog: false
  wolf is a retriever: false

  rover is a mammal: true
  rover is a canine: true
  rover is a dog: true
  rover is a retriever: true

Testing isInstance:
  Does a retriever bark? true
  Is a retriever a dog? true
  Is a dog necessarily a retriever? false

Strings

String s1 = "This is a String";

String s2 = new String("This is a String too");

String test = "foo" + "bar"; // "foobar"

String foo = "foo";
String bar = "bar";
String test = foo + bar;

String Methods

public char charAt(int index)

This method returns the character at the specified location.

public int compareTo(String comparison)

public int compareTo(Object object)

The compareTo method compares the current string to the supplied string, character by character, checking Unicode ordering. It returns 0 if the strings are equal (have the same characters), a negative number if the current string is lexicographically less than the comparison, and a positive number otherwise. This method is generally used for determining if strings are in order. The actual number is the difference in Unicode values between the first nonmatching characters, or the difference in lengths if the shorter string is a prefix of the longer one. To satisfy the Comparable interface, the method for objects was added in Java 1.2. It acts like the string compareTo method but throws a ClassCastException if the input is not a string.

public String concat(String suffix)

The concat method concatenates two strings, forming a new String. The following two forms are identical:

String result = someString.concat(someOtherString);
String result = someString + someOtherString;

Neither someString nor someOtherString is modified in these examples; instead a new String is created.

public static String copyValueOf(char[ ] characters)

public static String copyValueOf(char[ ] data, int startIndex, int count)

These static methods convert character arrays to strings.

public boolean endsWith(String suffix)

This method checks for a suffix of a string.

public boolean equals(Object comparison)

If the comparison object is not a String, equals returns false. Otherwise, it compares character by character. Thus, two different strings with the same characters will be equals but not ==. 

public boolean equalsIgnoreCase(String comparison)

This method performs a case-insensitive, character-by-character comparison.

public byte[ ] getBytes()

public byte[ ] getBytes(String encoding)

These methods convert a string to a byte array.

public void getChars(int sourceStart, int sourceEnd, char[ ] destination, int destinationStart)

This method copies the characters from sourceStart (inclusive) to sourceEnd (exclusive) into the specified part of the destination array.

public int indexOf(int character)

public int indexOf(int character, int startIndex)

public int indexOf(String subString)

public int indexOf(String subString, int startIndex)

These methods return the index of the first occurrence of the specified target.

public native String intern()

The intern method returns a canonical String containing the same characters as the supplied string. The interned result of two strings is == if and only if the strings themselves are equals.

public int lastIndexOf(int character)

public int lastIndexOf(int character, int startIndex)

public int lastIndexOf(String subString)

public int lastIndexOf(String subString, int startIndex)

These methods return the index of the last occurrence of the specified target.

public int length()

This method gives the length of the string. Note that this is a method call, not an instance variable. So, don't forget that for strings you have to do

int len = someString.length(); // length()

and for arrays you do

int len = someArray.length; // No parens

public boolean regionMatches(int startIndex1, String string2, int startIndex2, int count)

public boolean regionMatches(boolean ignoreCase, int startIndex1, String string2, int startIndex2, int count)

These methods perform a case-sensitive or -insensitive comparison of two substrings.

public String replace(char oldChar, char newChar)

The replace method returns a new String that is the result of replacing all occurrences of oldChar by newChar. The original string is not modified.

public boolean startsWith(String prefix)

public boolean startsWith(String prefix, int startIndex)

These methods check for string prefixes.

public String substring(int startIndex, int endIndex)

public String substring(int startIndex)

These methods return substrings in the specified range. If no ending index is supplied, the substring goes to the end of the original string.

public char[ ] toCharArray()

Use this method to generate a character array.

public String toLowerCase()

public String toLowerCase(Locale locale)

public String toUpperCase()

public String toUpperCase(Locale locale)

These methods convert the entire string to lower case or upper case, optionally using the rules of the specified locale.

public String trim()

This method returns a new String with leading and trailing white space and control characters removed. The original String is not modified.

public static String valueOf(boolean b)

public static String valueOf(char c)

public static String valueOf(char[ ] data)

public static String valueOf(char[ ] data, int startIndex, int count)

public static String valueOf(double d)

public static String valueOf(float f)

public static String valueOf(int i)

public static String valueOf(long l)

These static methods convert the specified primitive values to strings.

public static String valueOf(Object o)

This static method uses the object's toString method to generate a string.

public class StringTest {
  public static void main (String[] args) {
    String str = "";
    if (args.length > 0) {
        str = args[0];
    }
    if (str.length()>8) {
      System.out.println("String is \"" + str + "\"\n");
      System.out.println("  charAt(3) ------------------ " +
                         str.charAt(3));
      System.out.println("  compareTo(Moscow) ---------- " +
                         str.compareTo("Moscow"));
      System.out.println("  concat(SuFFiX) ------------- " +
                         str.concat("SuFFiX"));
      System.out.println("  endsWith(hic) -------------- " +
                         str.endsWith("hic"));
      System.out.println("  == Geographic -------------- " +
                         (str == "Geographic"));
      System.out.println("  equals(geographic) --------- " +
                         str.equals("geographic"));
      System.out.println("  equalsIgnoreCase(geographic) " +
                         str.equalsIgnoreCase("geographic"));
      System.out.println("  indexOf('o') --------------- " +
                         str.indexOf('o'));
      System.out.println("  indexOf('i',5) ------------- " +
                         str.indexOf('i',5));
      System.out.println("  indexOf('o',5) ------------- " +
                         str.indexOf('o',5));
      System.out.println("  indexOf(rap) --------------- " +
                         str.indexOf("rap"));
      System.out.println("  indexOf(rap, 5) ------------ " +
                         str.indexOf("rap", 5));
      System.out.println("  lastIndexOf('o') ----------- " +
                         str.lastIndexOf('o'));
      System.out.println("  lastIndexOf('i',5) --------- " +
                         str.lastIndexOf('i',5));
      System.out.println("  lastIndexOf('o',5) --------- " +
                         str.lastIndexOf('o',5));
      System.out.println("  lastIndexOf(rap) ----------- " +
                         str.lastIndexOf("rap"));
      System.out.println("  lastIndexOf(rap, 5) -------- " +
                         str.lastIndexOf("rap", 5));
      System.out.println("  length() ------------------- " +
                         str.length());
      System.out.println("  replace('c','k') ----------- " +
                         str.replace('c','k'));
      System.out.println("  startsWith(eog,1) ---------- " +
                         str.startsWith("eog",1));
      System.out.println("  startsWith(eog) ------------ " +
                         str.startsWith("eog"));
      System.out.println("  substring(3) --------------- " +
                         str.substring(3));
      System.out.println("  substring(3,8) ------------- " +
                         str.substring(3,8));
      System.out.println("  toLowerCase() -------------- " +
                         str.toLowerCase());
      System.out.println("  toUpperCase() -------------- " +
                         str.toUpperCase());
      System.out.println("  trim() --------------------- " +
                         str.trim());
      System.out.println("\nString is still \"" + str + "\"\n");
    }
  }
}

Listing 8.17 StringTest Output

  Prompt> java StringTest Geographic
  String is "Geographic"
  charAt(3) ------------------ g
  compareTo(Moscow) ---------- -6
  concat(SuFFiX) ------------- GeographicSuFFiX
  endsWith(hic) -------------- true
  == Geographic -------------- false
  equals(geographic) --------- false
  equalsIgnoreCase(geographic) true
  indexOf('o') --------------- 2
  indexOf('i',5) ------------- 8
  indexOf('o',5) ------------- -1
  indexOf(rap) --------------- 4
  indexOf(rap, 5) ------------ -1
  lastIndexOf('o') ----------- 2
  lastIndexOf('i',5) --------- -1
  lastIndexOf('o',5) --------- 2
  lastIndexOf(rap) ----------- 4
  lastIndexOf(rap, 5) -------- 4
  length() ------------------- 10
  replace('c','k') ----------- Geographik
  startsWith(eog,1) ---------- true
  startsWith(eog) ------------ false
  substring(3) --------------- graphic
  substring(3,8) ------------- graph
  toLowerCase() -------------- geographic
  toUpperCase() -------------- GEOGRAPHIC
  trim() --------------------- Geographic

String is still "Geographic"

Constructors

public String()

This constructor builds a zero-length but non-null string.

public String(byte[ ] bytes)

public String(byte[ ] bytes, String encoding)

public String(byte[ ] bytes, int startIndex, int count)

public String(byte[ ] bytes, int startIndex, int count, String encoding)

These constructors build a string from byte arrays.

public String(char[ ] chars)

public String(char[ ] chars, int startIndex, int count)

These constructors build a string from character arrays.

public String(String string)

This constructor copies the string. The result is equals but not == to the input.

public String(StringBuffer stringBuffer)

This constructor converts a StringBuffer to a String.

 Arrays

• Their length can be determined through the length field.
• They can be assigned to variables of type Object as well as to variables of their specific type.
• Arrays are efficiently passed to methods by reference just like any other Object.

Two-Step Array Allocation

int[] values = new int[2]; // a 2-element array
Point[] points = new Point[5]; // a 5-element array
int numNames = askHowManyNames(); // Set at runtime
String[] names = new String[numNames];

values[0] = 10;
values[1] = 100;
for(int i=0; i<points.length; i++) {
  points[i] = new Point(i*2, i*4);
}
for(int j=0; j<names.length; j++) {
  names[j] = "Name " + j;
}

SomeObject[] objArray = new SomeObject[n];

Type someVar[] = ...

Type[] someVar = ...

One-Step Array Allocation

int[] values = { 10, 100 };
Point[] points = { new Point(0, 0),
                   new Point(2, 4),
                   new Point(4, 8),
                   ... };

 Golf.java

/** Report on a round of golf at St. Andy's. */

public class Golf {
  public static void main(String[] args) {
    int[] pars   = { 4,5,3,4,5,4,4,3,4 };
    int[] scores = { 5,6,3,4,5,3,2,4,3 };
    report(pars, scores);
  }

  /** Reports on a short round of golf. */
  public static void report(int[] pars, int[] scores) {
    for(int i=0; i<scores.length; i++) {
      int hole = i+1;
      int difference = scores[i] - pars[i];
      System.out.println("Hole " + hole + ": " +
                         diffToString(difference));
    }
  }

  /** Convert to English. */

  public static String diffToString(int diff) {
    String[] names = {"Eagle", "Birdie", "Par", "Bogey",
                      "Double Bogey", "Triple Bogey", "Bad"};
    // If diff is -2, return names[0], or "Eagle".
    int offset = 2;
    return(names[offset + diff]);
  }
}

 Golf Output

Prompt> java Golf
Hole 1: Bogey
Hole 2: Bogey
Hole 3: Par
Hole 4: Par
Hole 5: Par
Hole 6: Birdie
Hole 7: Eagle
Hole 8: Bogey
Hole 9: Birdie

Multidimensional Arrays

int[][] values = new int[12][14];
for(int i=0; i<12; i++) {
  for(int j=0; j<14; j++) {
    values[i][j] = someFunctionOf(i, j);
  }
}

int someVal = values[i][j]; // i<12, j<14
values[i][j] = someInt;

int[] someArray = values[i]; // 0<=i<=11
values[i] = someOtherArray;

String[][] names = new String[3][];
String[] name0 = { "John", "Q.", "Public" };
String[] name1 = { "Jane", "Doe" };
String[] name2 = { "Pele" };
names[0] = name0; // 3 elements
names[1] = name1; // 2 elements
names[2] = name2; // 1 element

String[][] altNames = { { "John", "Q.", "Public" },
                        { "Jane", "Doe" },
                        { "Pele" }
                      };

Vectors

Constructors

public Vector()

public Vector(int initialCapacity)

public Vector(int initialCapacity, int capacityIncrement)

These constructors build an empty Vector. The initial capacity (size of the underlying array) is 10 if not specified, but Java automatically copies the data into a bigger array if more elements are added than the current vector size allows.

Methods

public void addElement(Object object)

public void insertElementAt(Object object, int index)

public void setElementAt(Object object, int index)

These synchronized methods add elements to the Vector. The addElement method inserts at the end; the other two methods use the location specified. With insertElementAt, the objects at and to the right of the specified location are shifted one location to the right. WithsetElementAt, the object at the specified location is replaced.

public int capacity()

This method returns the size of the underlying array, that is, the number of elements the Vector can hold before it will be resized.

public boolean contains(Object object)

The contains method determines whether the Vector contains an object that equals the one specified.

public void copyInto(Object[ ] newArray)

This synchronized method copies the object references into the specified array, in order.

public Object elementAt(int index)

The synchronized elementAt method returns the element at the specified location.

public Enumeration elements()

The java.util.Enumeration class defines an interface used by several enumerable classes. You can use elements to get an Enumerationobject corresponding to the Vector.

public void ensureCapacity(int minimum)

This synchronized method guarantees that the underlying array has at least the specified number of elements.

public Object firstElement()

public Object lastElement()

These synchronized methods return the first and last entry in the Vector, respectively.

public int indexOf(Object object)

public int indexOf(Object object, int startIndex)

public int lastIndexOf(Object object)

public int lastIndexOf(Object object, int startIndex)

These synchronized methods return the leftmost or rightmost index of the element that equals the object specified.

public boolean isEmpty()

This method returns false if the Vector has any elements; true otherwise.

public boolean removeElement(Object object)

public void removeElementAt(int index)

public void removeAllElements()

These synchronized methods let you remove entries from the Vector.

public void setSize(int newSize)

This synchronized method sets a specific size for the Vector. It differs from ensureCapacity in that it will truncate the Vector if the Vector is larger than the specified size.

public int size()

The size method returns the number of elements in the Vector (not the size of the underlying array, which might be larger).

public void trimToSize()

This synchronized method sets the underlying array to be exactly the same size as the current number of elements. You should avoid this method while elements are being added and removed, but it might save memory if the method is used once the Vector elements are fixed.

8.11 Example: A Simple Binary Tree

 Node.java

import java.util.Vector;

/** A data structure representing a node in a binary tree.
 *  It contains a node value and a reference (pointer) to
 *  the left and right subtrees.
 */

public class Node {
  private Object nodeValue;
  private Node leftChild, rightChild;

 /** Build Node with specified value and subtrees. */

  public Node(Object nodeValue, Node leftChild,
              Node rightChild) {
    this.nodeValue = nodeValue;
    this.leftChild = leftChild;
    this.rightChild = rightChild;
  }

  /** Build Node with specified value and L subtree. R child
   *  will be null. If you want both children to be null, use
   *  the Leaf constructor.
   */

  public Node(Object nodeValue, Node leftChild) {
    this(nodeValue, leftChild, null);
  }

  /** Return the value of this node. */

  public Object getNodeValue() {
    return(nodeValue);
  }

  /** Specify the value of this node. */

  public void setNodeValue(Object nodeValue) {
    this.nodeValue = nodeValue;
  }

 /** Return the L subtree. */

  public Node getLeftChild() {
    return(leftChild);
  }

  /** Specify the L subtree. */

  public void setLeftChild(Node leftChild) {
    this.leftChild = leftChild;
  }

  /** Return the R subtree. */

  public Node getRightChild() {
    return(rightChild);
  }

  /** Specify the R subtree. */

  public void setRightChild(Node rightChild) {
    this.rightChild = rightChild;
  }

  /** Traverse the tree in depth-first order, applying
   *  the specified operation to each node along the way.
   */

  public void depthFirstSearch(NodeOperator op) {
    op.operateOn(this);
    if (leftChild != null) {
      leftChild.depthFirstSearch(op);
    }
    if (rightChild != null) {
      rightChild.depthFirstSearch(op);
    }
  }

  /** Traverse the tree in breadth-first order, applying the
   *  specified operation to each node along the way.
   */

  public void breadthFirstSearch(NodeOperator op) {
    Vector nodeQueue = new Vector();
    nodeQueue.addElement(this);
    Node node;
    while(!nodeQueue.isEmpty()) {
      node = (Node)nodeQueue.elementAt(0);
      nodeQueue.removeElementAt(0);
      op.operateOn(node);
      if (node.getLeftChild() != null) {
        nodeQueue.addElement(node.getLeftChild());
      }
      if (node.getRightChild() != null) {
        nodeQueue.addElement(node.getRightChild());
      }
    }
  }
}

NodeOperator.java

/** An interface used in the Node class to ensure that
 *  an object has an operateOn method.
 */

public interface NodeOperator {
  void operateOn(Node node);
}

 Leaf.java

/** Leaf node: a node with no subtrees. */

public class Leaf extends Node {
  public Leaf(Object value) {
    super(value, null, null);
  }
}

 

 TreeTest.java

/** A NodeOperator that prints each node. */

class PrintOperator implements NodeOperator {
  public void operateOn(Node node) {
    System.out.println(node.getNodeValue());
  }
}

/** A sample tree representing a parse tree of
 *  the sentence "Java hackers hack Java", using
 *  some simple context-free grammar.
 */

public class TreeTest {
  public static void main(String[] args) {
    Node adjective =
      new Node("  Adjective", new Leaf("   Java"));
    Node noun1 =
      new Node("  Noun", new Leaf("   hackers"));
    Node verb =
      new Node("  TransitiveVerb", new Leaf("   hack"));
    Node noun2 =
      new Node("  Noun", new Leaf("   Java"));
    Node np = new Node(" NounPhrase", adjective, noun1);
    Node vp = new Node(" VerbPhrase", verb, noun2);
    Node sentence = new Node("Sentence", np, vp);
    PrintOperator printOp = new PrintOperator();
    System.out.println("Depth first traversal:");
    sentence.depthFirstSearch(printOp);
    System.out.println("\nBreadth first traversal:");
    sentence.breadthFirstSearch(printOp);
  }
}

 TreeTest Output

Prompt> java TreeTest
Depth first traversal:
Sentence
 NounPhrase
  Adjective
   Java
  Noun
   hackers
 VerbPhrase
  TransitiveVerb
   hack
  Noun
   Java

Breadth first traversal:
Sentence
 NounPhrase
 VerbPhrase
  Adjective
  Noun
  TransitiveVerb
  Noun
   Java
   hackers
   hack
   Java

 Exceptions

Basic Form

try {
  statement1;
  statement2;
  ...
} catch(SomeException someVar) {
  handleTheException(someVar);
}

import java.net.*; // For URL, MalformedURLException
import java.io.*;  // For BufferedReader

/** A small class to demonstrate try/catch blocks. */

public class URLTest {
  public static void main(String[] args) {
    URLTest test = new URLTest();
    test.getURL();
    test.printURL();
  }

  private URL url = null;

  /** Read a string from user and create a URL from it. If
   *  reading fails, give up and report error. If reading
   *  succeeds but URL is illegal, try again.
   */

  public URL getURL() {
    if (url != null) {
      return(url);
    }
    System.out.print("Enter URL: ");
    System.out.flush();
    BufferedReader in = new BufferedReader(
                          new InputStreamReader(System.in));
    String urlString;
    try {
      urlString = in.readLine();
    } catch(IOException ioe) {
      System.out.println("IOError when reading input: " + ioe);
      ioe.printStackTrace(); // Show stack dump.
      return(null);
    }
    try {
      url = new URL(urlString);
    } catch(MalformedURLException mue) {
      System.out.println(urlString + " is not valid.\n" +
                         "Try again.");
      getURL();
    }
    return(url);
  }

  /** Print info on URL. */

  public void printURL() {
    if (url == null) {
      System.out.println("No URL.");
    } else {
      String protocol = url.getProtocol();
      String host = url.getHost();
      int port = url.getPort();
      if (protocol.equals("http") && (port == -1)) {
        port = 80;
      }
      String file = url.getFile();
      System.out.println("Protocol: " + protocol +
                         "\nHost: " + host +
                         "\nPort: " + port +
                         "\nFile: " + file);
    }
  }
}

URLTest Output

> java URLTest
> Enter URL: http://java.sun.com/ConvertingToActiveX.html
Protocol: http
Host: java.sun.com
Port: 80
File: /ConvertingToActiveX.html

new Throwable().printStackTrace();

Multiple Catch Clauses

Simplified getURL Method

public URL getURL() {
  if (url != null) {
    return(url);
  }
  System.out.print("Enter URL: ");
  System.out.flush();
  BufferedReader in = new BufferedReader(
                        new InputStreamReader(System.in));
  String urlString = null;
  try {
    urlString = in.readLine();
    url = new URL(urlString);
  } catch(MalformedURLException mue) {
    System.out.println(urlString + " is not valid.\n" +
                      "Try again.");
    getURL();
  } catch(IOException ioe) {
    System.out.println("IOError when reading input: " + ioe);
    ioe.printStackTrace(); // Show stack dump
    return(null);
  }
  return(url);
}

The Finally Clause

public URL getURL() {
  if (url != null) {
    return(url);
  }
  System.out.print("Enter URL: ");
  System.out.flush();
  BufferedReader in = new BufferedReader(
                        new InputStreamReader(System.in));
  String urlString = null;
  try {
    urlString = in.readLine();
    url = new URL(urlString);
  } catch(MalformedURLException mue) {
    System.out.println(urlString + " is not valid.\n" +
                       "Try again.");
    getURL();
  } catch(IOException ioe) {
    System.out.println("IOError when reading input: " + ioe);
    ioe.printStackTrace(); // Can skip return(null) now
  } finally {
    return(url);
  }
}

Thrown Exceptions

public SomeType someMethod(...) throws SomeException {

public SomeType someMethod(...)
       throws ExceptionType1, ExceptionType2 {

throw new IOException("Blocked by firewall");
throw new MalformedURLException(
            "Invalid protocol: telephone");

 NegativeLengthException.java

import java.io.*;

public class NegativeLengthException extends Exception {

  /** Test NegativeLengthException */

  public static void main(String[] args) {
    try {
      int lineLength = readLength();
      for(int i=0; i<lineLength; i++) {
        System.out.print("*");
      }
      System.out.println();
    } catch (NegativeLengthException nle) {
      System.out.println("NegativeLengthException: " +
                         nle.getMessage());
    }
  }

  public NegativeLengthException() {
    super("Negative dimensions not permitted.");
  }

  public NegativeLengthException(String message) {
    super(message);
  }
  // readLength catches IOExceptions locally but lets the
  // calling method handle NegativeLengthExceptions.
  private static int readLength() throws NegativeLengthException {
    BufferedReader in = new BufferedReader(
                          new InputStreamReader(System.in));
    System.out.print("Enter length: ");
    System.out.flush();
    int len = 0;
    try {
      String line = in.readLine();
      len = Integer.parseInt(line);
      if (len < 0) {
        throw new NegativeLengthException();
      }
    } catch (IOException ioe) {
      System.out.println("Problem reading from keyboard");
    }
    return(len);
  }
}

 Throwing NegativeLengthExceptions

> java NegativeLengthException
> Enter length: 4
****

> java NegativeLengthException
> Enter length: -345
NegativeLengthException: Negative dimensions not permitted.

Unchecked Exceptions

You Might Also Like