Module 2: Elementary Java, Part I

Java Syntax

• Java Syntax is very close to C/C++'s.
• The following are Java's reserved words (some are not in use today):

abstract, assert1.4 boolean, break, byte, case, catch, char, class, const*, continue, default, do, double, else, enum1.5, extends, false, final, finally, float, for, goto*, if, implements, import, instanceof, int, interface, long, native, new, null, package, private, protected, public, return, short, static, strictfp1.2, super, switch, synchronized, this, throw, throws, transient, true, try, void, volatile, while

* not used 1.2: added in 1.2 1.4: added in 1.4 1.5: added in 1.5

• Total: 53 reserved words.

NOTE: Earlier versions of Java included additional reserved words (such as byvalue, cast, future, generic, inner, operator, outer, var) that are not reserved anymore.

• Not in use: const, goto (2 words).
• Reserved words for data types and values:
• boolean - boolean data type
• byte - standard 8-bit byte
• char - Unicode character (2 bytes)
• double - 8-byte real number
• false - value of a boolean type
• float - 4-byte real number
• int - 4-byte integer
• long - 8-byte integer
• null - null reference to an object
• short - 2-byte integer
• true - value of a boolean type
• void - when a function does not return a value
• enum- enumerated type
• Reserved words for objects and packages:
• abstract - to declare objects/methods that require implementation via inheritance
• class - object declaration
• extends - to declare inheritance
• implements - to declare an implementation of an interface
• import - to ask the compiler to bring in named packages
• interface - to specify an object, but not implement it
• package - for grouping together related objects
• super - reference to the parent object by an inheriting object
• Reserved words for declaration modifiers:
• final - to declare constants and to prohibit inheritance
• native - to use C functions
• private - visibility modifier
• protected - visibility modifier
• public - visibility modifier
• static - to declare something as class-based as opposed to instance-based
• synchronized - for mutual exclusion in multithreading
• throws - for throwing an exception (declaration)
• transient - to indicate data that should not be stored to disk (during serialization)
• volatile - to indicate data used in synchronization that should be handled with care by an optimizing compiler
• strictfp - to enforce "strictfp" rules for floating-point arithmetic
• Reserved words for operators:
• instanceof - to see whether an object is of a given type
• new - to create an object instance
• this - a reference to the current object
• Keywords for control statements:
• break - to break out of loops or conditionals
• case - case statement item
• catch - for catching exceptions
• continue - shortcut to a loop's next iteration
• default - case statement default action
• do - do-while statement
• else - conditional
• finally - last must-execute clause of a try statement
• for - for loop
• if - conditional
• return - return a value in a function
• switch - case statement
• throw - to throw an exception
• try - try statement to handle potential exceptions
• while - while-loop, do-while loop

// This is an in-line comment. It ends at the end of this line.

// This attempt to roll to the next 
line will fail to compile.

/* Instead, long comments are best
   placed inside block comments
   like this */

/** 
 * Finally, there is the type of documentation that
 * javadoc produces. To use this, you need to use javadoc
 * commands inside the comment block, such as:
 * @version 1.1
 * @author Rahul Simha
 * @return No value returned
 * @param  command arguments (any number of strings)
 * Note: each line must start with a `*' symbol.
 */

// javadoc will produce HTML documentation. To try it out, don't
// forget to fix the in-line comment error above.

public class helloworld3 {
  public static void main (String[] argv)
  {
    System.out.println ("Hello World!");   // prints to screen
  }
}

Rule: Your Java source file (e.g., helloworld.java) can have many class 'es, but at least one class must have the same name (helloworld ) as the file and that class must have a main function if you want to execute the class directly. The program will start execution in that main function.

public class Test {
  public static void main (String[] argv)
  {
    // Put your code in here
  }
}

In-class exercise 2.1: What happens if you do not have a main function in your file? Try compiling and executing such a file.

Variables and assignment

Variables are declared by following the type keyword with the identifier:

  byte b;                 // A byte
  int i;                  // i is a 4-byte integer
  long num_stars;         // A long integer
  float epsilon, delta;   // Multiple variables separated by a comma      
  double                  // Often, you use several lines for commenting:
    pi,                   // 3.14159
    e,                    // 2.718
    squareRootOfTwo;      // Use Math lib for computing this
  boolean over;

Assignment uses the assignment operator =

  int i, j;
  i = 7;
  j = 2000;

Variable declarations can occur almost anywhere in a block of code.
Declarations and assignment can be combined where appropriate:

  double pi = 3.14159;         // Declaration and assignment combined
  int i = 3;
  double threePi;              // Pure declaration

  while (true) {
    threePi = i * pi;          // Pure assignment
    double fourPi  = pi * 4;   // Combination in a sub-block of code
  }

NOTE:

• It's good practice to initialize every variable in the declaration itself.
• Class variables are automatically initialized: objects to null, numbers to 0, and booleans to false.
• The compiler will complain if you do not initialize local variables.
• Java statements end with a semi-colon.
• Java code blocks are delimited with braces.
• Expressions are delimited with brackets.

Constants

Constants in Java are a little strange.
Currently, the only way to declare a constant is as follows:

public class Test {

  public static final double pi = 3.14159;

  public static void main (String[] argv)
  {
    double d = pi;
  }
}

NOTE:

• There is no such thing as a global constant.
• To make a constant global (across files), use public.
• Later, we will understand what static and final mean.

Conversions and casting

Can the contents of an int variable be copied into a (assigned to) long variable? (Yes).

Can an doublebe assigned to a double? (Not directly).

   int i = 5;
   long j;
   double d = 3.141;

   j = i;              // Fine - an example of an implicit cast.
   i = d;              // Won't compile - needs an explicit cast.
   d = i;              // Fine (implicit cast).

   int i = 5;
   long j;
   double d = 3.141;

   j = (long) i;              // Not really needed.
   i = (int) d;               // Truncates the real value;
   System.out.println (i);    // Prints `3'

public class TestOperators
{
  public static void main (String[] argv)
  {
    int i = 5;

    i = i + 1;
    i += 1;            // Same as i = i+1;

    // Pre and post-use increment
    i = 10;
    System.out.println (++i);    // Prints 11
    i = 10;
    System.out.println (i++);    // Prints 10

    // Comparison operators: < > <= >= == !=
    int j = 10;
    if (i != j)
      System.out.println ("Help! i not equal to l!");

    // Casting
    byte b = 8;
    long l = 100;
    i = i + b;         // b is automatically converted to an int
    i = i + l;         // Illegal - explicit cast required
    i = i + (int) l;   // OK (explicit downward cast)
    b = b + 1;         // Illegal: `1' is an integer
    l = l + 1;         // OK, `1' is up-cast.
    b++;               // OK, within type.

    // Bitwise operators: & | ^ << >> >>> &= |= ^= <<= >>= >>>=
    int x1 = 8, x2 = 15;
    int x3 = x1 & x2;
    System.out.println (x3);  // What does this print?

    // Boolean type
    boolean tired = true;
    boolean had_enough = true;

    // Boolean operators: && || !
    if (tired && had_enough)
      System.out.println ("Go home");
  }

}

public class TestStrings {

  public static void main (String[] argv)  // Actually, an array of strings
  {
    // Definition
    String m = "Yes, I had tea in the Oval Office that Monday";
    String b = "What is the definition of tea?";

    // Printing
    System.out.println ("Monica: " + m // Note concatenation
                        + "\n" +       // Expressions can spill over
                        "Bill: " + b); // lines but strings may not.

    int i = b.length(); // length() method returns # chars in string

    System.out.println ("String \"" // Note backslash-quote
                        + b + "\" has length " 
                        + i  // Automatic conversion to string
                        + " chars");

    // Assignment
    String b2 = b;     // Actually, a pointer. But since strings are
                       // immutable, there's no problem.
    System.out.println ("b2: " + b2);

    // Modifying strings using String methods
    String b3 = b.substring (0,6);  // First 7 letters
                                    // Must extract into a new string
    System.out.println ("b3: " + b3);

    // Extracting individual characters
    char c1 = b.charAt (0);
    char c2 = b.charAt (2);
    System.out.println ("c1+c2: " + c1 + c2);

    // Testing equality
    if (b2.equals(b))
      System.out.println ("b2 equals b");

    // Short-cut operator:
    b2 += b2;                 // Concatenate a string with itself.
    System.out.println ("b2: " + b2);

  }
}

public class TestArray {

  public static void main (String[] argv)
  {
    // Declaration: A is an array of int's
    int[] A;
    
    // The new operator instantiates an array with a given size.
    A = new int[10];

    // Individual items are referred to using square brackets.
    // Indexing starts from 0.
    for (int i=0; i<10; i++)
      A[i] = i;
    
    // This will compile but create a runtime exception.
    A[10] = 5;
    
    // A.length is a field indicating the length.
    System.out.println ("Number of elements of array A: " + A.length
                        + "\nContents:");
    
    // Size can be determined dynamically.
    int size = 10;
    double[] B = new double[size];
    
    // Arrays can be initialized
    String[] C = {"Michael", "Scottie", "Toni", "Dennis", "Luc"};
    
  }
}

% java TestCommandLine aaa aaaa
Arg#0 = aaa, length = 3
Arg#1 = aaaa, length = 4
Average: 3.5

public class Test2DArray {

  public static void main (String[] argv)
  {
    int size = 5;
    int[][] identMatrix;

    // Create the first dimension - an array
    identMatrix = new int[size][];

    // Create the second dimension - an array for each 
    // element of the first dimension.
    for (int i=0; i < size; i++)
      identMatrix[i] = new int[size];   // The size can be changed
                                         // dynamically.

    // We're done creating the 2D array. Now create the
    // identity matrix and print it out.
    System.out.println ("Identity matrix of size: " + size);
    for (int i=0; i < size; i++) {
      for (int j=0; j < size; j++) {
        if (i == j) 
          identMatrix[i][j] = 1;
        else 
          identMatrix[i][j] = 0;
        System.out.print (identMatrix[i][j] + " ");
      }
      System.out.println ();
    }
  }
}

public class Test2DArray2 {

  public static void main (String[] argv)
  {
    int size = 5;
    int[][] triangle;

    // There are `size' rows.
    triangle = new int[size][];

    // Each row has a different number of elements.
    for (int i=0; i < size; i++)
      triangle[i] = new int[i+1];

    // Compute elements
    System.out.println ("Triangle of 1's:");

    for (int i=0; i < size; i++) {

      // Count enough blanks for i-th row.
      for (int j=0; j < size-i; j++)
        System.out.print (" ");

      // Print out 1's. Note length reference as an alternative.
      for (int j=0; j < triangle[i].length; j++) {
        triangle[i][j] = 1;
        System.out.print ("1 ");
      }

      System.out.println ();
    }
  }
}

     1 
    1 1 
   1 2 1 
  1 3 3 1 
 1 4 6 4 1