Java Review

Java development environment

• while (not happy with the results) {
  1. edit a source file using a text editor
  2. then compile
  3. then execute
• }
• alternative: use an Integrated Development Environment, or IDE
• JDK can compile, JRE (included in JDK) can execute
• Eclipse, jGrasp, NetBeans

Java errors

• syntax errors
  • at compile time
  • detected by IDE
  • IDE may be able to help you to correct them
  • "easy" to correct, if you know Java
• execution errors are different: how do they differ?
  • run-time
  • exceptions, errors (Throwable objects)
    • either you catch them,
    • or the executive will
      • aborts the program
  • harder to correct
• logical errors
  • program runs flawlessly
  • but results are wrong
  • e.g. watch out for integer overflow, numeric errors, etc.
  • the hardest to detect
    • test program with
      1. typical input
      2. all combinations of boundary conditions (exceptional states)
  • causes: programmer lack of understanding, sloppiness, and/or hurry
• good programming: check all values to make sure they are as you expect them to be
• better programming: deal with values or conditions that are not what your code expects them to be

Programming Style

• Efficiency has several aspects
  • time (how long does it take to produce results)
  • space (how much memory - RAM, disk - is needed)
  • maintenance (how easy is it to write, test, debug and improve your program)
• Maintenance is often the most important aspect
• Readability of your programs is crucial
  • use indenting to highlight nesting structure
  • document:
    • good names are self-documenting, they must reflect the purpose
      • variables have purpose, too - give them good names
    • each class, method, parameter, return value, instance variable must be preceded by a comment explaining its purpose
      • use standard Javadoc format
    • be explicit, but terse
      • no 1-letter names, except for counters, names used customary (in another domain - such as x, y in math), common abbreviations, etc.
      • e.g., no "This method computes ..."
        • if the comment precedes a method it documents "this method"
        • every method "computes" something
    • no empty lines within a method body
      • programers use them to separate logical blocks
      • don't be that lazy - if a new logical block starts, fill the line with a comment that tells the reader what is its purpose
    • never use one variable for two different purposes
  • simplify expressions
    • avoid assignments within an expression!
      • e.g., x = 10 + y = 4;
    • avoid wrapping long lines, if possible
    • use temporary variables for sub-expressions
  • modularize
    • don't have a sequence of the same statements (or even similar statements) in your code twice
      • use a method to contain them, use parameters to account for differences
    • if a method is used in several programs, put it into a class
      • also, think "could it be used eventually in another program"?
  • if you think of cutting & pasting your code, think twice - it usually can be modularized
  • modular code is
    • simpler to debug
    • simpler to change
    • easier to read
    • reusable
• Java coding standard helps refine your style

Java variables

• Java is a strongly-typed language
  • every variable must have a type
  • a variable can be assigned only a value of this type
  • sometimes, a value can be converted to the variable's type
    • implicitly
      • by "widening" to type with more values
        • float x = 1;
        • assigning an object of subclass to a variable of superclass type
    • explicitly, by casting, e.g., int i = (int) 2.0;
• local variables only have scope from their declaration to the end of the block
  • parameters have scope within the method
• scope of an instance variable is the containing class
• inner declarations override outer declarations
  • this is mostly a bad programming practice
    • the reader may not realize which of the equally-named variables the programmer uses
      • e.g. count = count + 3;
        when there is more than one count variable, this will modify the innermost one even though the programmer may intend to modify the outer count variable
  • except when a parameter is used to set the value of an instance variable, e.g.,

    • class Student {
        private String name;
        public void setName (String name) {this.name = name;}
      }

  • because this makes the instance variable clearly stand out
• instance variables should be private or protected
  • declaring them public is mostly a bad programming practice
• static variables "belong" to the class
  • they are often public, e.g. constants
  • outside of the class, they have to be qualified by the class name

Arrays

• arrays are objects
  • that contain other values, the array elements
• each element is identified by an integer in (0...array.size-1), the array index or subscript
• like any variable, arrays must be declared
• unlike integers or booleans, arrays must be initialized, that is, allocated or instantiated, e.g.

  String [] names = new String [15];
  boolean [] bits = new boolean [99];
  

  which creates an array of size 15 with indices 0..14
• what type does the expression "names [7]" have?
• within a declaration, an array can be initialized by listing all of its elements
  • e.g., String [] names = {"James", "Jack, "Ann"};

Array initialization, operations

• an array that is not initialized to an allocated value has the special value null, which cannot be indexed
• initializing the array (the container) is different from initializing each of the elements
  • first the array must be initialized, then the elements
• initializing array elements one by one can be done as follows

     coinNames[4] = "half";
  

  This could be done within a loop, e.g.

     a[i] = i*7;
  

• or all can be initialized and allocated at once, e.g.

  double [] x = {1.0, 2.71, 3.14, 4.0};
  

• the length of an array is one more than the highest usable index

     int i = 0;
     while (i < x.length) {
       x [i] += 1.0;
     }
  

• arraycopy can be used to copy elements from one existing array to another existing array:

  System.arraycopy(sourceArray, sourceAt,
                   targetArray, targetAt, elementCount);
  

  all the element positions must be valid, specifically:
  • sourceAt through sourceAt + elementCount - 1 on sourceArray, and
  • targetPos through targetArray + elementCount - 1 on targetArray

Java booleans and boolean expressions

• variables of type boolean have either the value true or the value false
• expressions of type boolean have either the value true or the value false
• for example, x < y is either true or false
• arithmetic values or expressions can be used in comparisons:
  • < <= == != >= >
• for objects, == compares the addresses (do these two reference the same object?), whereas the equals method may perform a different comparison and is usually the one to use
• boolean expressions or values can be combined using the logical operators:
  • && || !
• boolean expressions and values are used to determine which code gets executed in conditional statements and or how often it gets executed in loops

Java conditional statements

if (a > b) {
  x = 3.0;
} else if (a > c) {
  x = 2.2;
} else {
  a = 99;
}

• the part after the first if is executed if the first condition is true
• otherwise the part after the first else is executed, including evaluating the next boolean expression

Java loops

• These two sets of statements are equivalent:

      beforeLoop ();              for (beforeLoop (); condition (); update ()) {
      while (condition ()) { 
        loopBody ();                loopBody ();
        update ();
      }                           }
  

• while loop is good when something needs to be done zero or more times:

     while(x > 0) {
       x -= y;
       y = y * 2;
     }
  

• do .. while can be used to execute statements one or more times:

     do {
       x -= y;
       y = y * 2;
     } while (x > 0);
  

• for loop is particularly useful with "counter" variables:

     for (int i = 0; i < a.length; i++) {
       a [i] *= 2;
     }
  

Modulo operator

• the operation of dividing two integers gives two results: a quotient and a remainder
• For example 11 / 4 = 2 with a remainder of 3
• the quotient is given by the division operator:

     int quotient = 11 / 4;
  

• the remainder is given by the modulo operator:

     int remainder = 11 % 4;
  

• the remainder operator must be learned since it is used in this class and is commonly used in programming
• for example, to get a random binary number (0 or 1), I can do:

     Random myRandomGenerator = new Random ();
     int random = myRandomGenerator.nextInt () % 2;
  

  the result is always zero or one

Ternery ? : operator

• ? : operator uses three operands
  • op₁ ? op₂ : op₃
    • op₁ must be a boolean expression, i.e. either true or false
    • the values of op₂ and op₃ must be the same (or compatible)
  • the result of op₁ ? op₂ : op₃ is either
    • op₂, if op₁ is true, or
    • op₃, if op₁ is false, or
  • in other words, the result of
    • x = op₁ ? op₂ : op₃
  • is the same as
    • if (op₁) {x = op₂} else {x = op₃}
• but ? : is better than if-else
  • it's shorter
  • easier to read
  • easier to understand once you get used to it
• we will use it often

Java exceptions

• try block followed by one or more catch blocks:

  try {
    /* code which may throw exception */
  } catch (exceptionClass1 variable1) {
    /* code which handles exception of type exceptionClass1 */
  } catch (exceptionClass2 variable2) {
    /* code which handles exception of type exceptionClass2 */
  } finally {
    /* code executed after try or catch */
  }
  

• example (from book, p. 76)

  try {
    /* something that may cause IOException */
  } catch (IOException error) {
    error.printStackTrace ();
    System.exit (1);
  }
  

• an uncaught exception is caught by the runtime system: this is a run-time error
  • but not all run-time errors result in exceptions!
• More on exceptions to come!

Java command line arguments -- reminder

• argument to main is an array of strings
• these strings can be specified on the command line, e.g. java MyProgram arg1 arg2 arg3
• e.g. java GetPhoneNumber jan, the first (and only) array element has the value "jan"
• we can loop over arguments (with for, while, or even recursion)
• IDEs each have their own way of setting "command line" arguments

Read

• anything you are not familiar with, by using the course resources: the TA in lab, the textbook, the instructor.
• you should be familiar with the material in Appendix A and sections 2.1-2.4 of the textbook