CS 541 Meeting -*- Outline -*-

* Other features of Java

** portability
------------------------------------------
             PORTABILITY

What helps Java code be more easily
portable?






------------------------------------------
         by minimizing machine dependencies
                -lots of built in standard libraries
                -bytecodes and exact semantics for the language
                        properties of types,
                        order of evaluation, etc.
                -binary compatability (through the JVM, even on diff machines)

        Q: And how does that compare to C or C++?
                trades run-time efficiency for it

** initialization
	all variables must be given a value before use

------------------------------------------
         INITIALIZATION

All variables


void foo(Float f) {
  Double d;
  if (...) {
     d = new Double(7.3 + f);
  } else {
     ...
  }
  Double d2 = d;


}
------------------------------------------
        ... must be initialized before first use,
                and the compiler statically enforces this

        explain the analogy to type checking here

** final
 
------------------------------------------
                  FINAL

final double pi = 3.14159;

class Foo {
  public final void int f() { ... }
}

final class Bar extends Foo {
  

}
------------------------------------------
        used like const in C++ on fields in Java

        more interesting is it's use in preventing subclassing or overriding
                of methods

        Q: Why would one want to prevent overriding a method?
                security, behavioral guarantees
                efficiency (allow compiler to treat it specially)
                        
        Q: Why would one want to prevent a class from being subclassed?
                efficiency (allow compilers to know about its objects)
                security, behavioral guarantees

** control flow

------------------------------------------
               CONTROL FLOW

Like C/C++ but:
        


search: {
   if (k == i) {
      loop: for (z = 0; z < size; z++) {
         if (a[z] == j) {
              break search;
         }
         for (y = 0; y < lb; y++) {
           ...
           if (a[z] < m && b[y] > q) {
              continue loop;
           }
           ...
      }
      ...
    }
  }
}
------------------------------------------
        ... no goto
                (too bad they didn't fix switch...)
            adds break <lablel>
                 continue <label>

        Q: In what way is this more "structured" than a goto?

** threads
        synchronized methods obtain an exclusive lock on the object
        synchronized statements lock a given object for a block of code
------------------------------------------
       THREAD-SAFE CODE (MONITORS)

synchronized void doWhenCondition() {
  while (!condition) {
    wait();
  }
  ... processing for when condition holds
}

synchronized void changeCondition() {
  ... change some value used in condition
  notify(); // or notifyAll();
}
------------------------------------------
        picture this as a room with one door,
                and a waiting room off to the side.

        wait() atomically "puts the thread in the waiting room" by
                - making the thread not scheduled for execution
                - releasing the lock 
                        (and all other object locks the thread holds)
            The waiting thread then waits to be notified by another thread
                using the same object

        notify() makes it so "the oldest thread in the waiting room
                                will reenter when this thread leaves"
                - schedules the longest waiting thread in the set of waiters

        can use notifyAll() instead, to notify all waiting threads.

------------------------------------------
class Stack {  // STACK AS A MONITOR
  int maxSize, siz;
  Object[] elems;
  public synchronized void push(Object o) 
             throws InterruptedException {
    while (full()) { wait(); }
    elems[siz - 1] = o;
    notifyAll();
  }
  public synchronized void pop() {
    if (!empty()) { siz -= 1; }
    notifyAll();
  }
  public synchronized Object top()
             throws InterruptedException {
    while (empty()) { wait(); }
    return elems[siz - 1];
  }
  public synchronized boolean full() {
    return siz == maxSize;
  }
  public synchronized boolean empty() {
    return siz == 0;
  }
  Stack(int msiz) {
    maxSize = msiz;
    siz = 0;
    elems = new Object[msiz];
  }
}

------------------------------------------
        This (dubious) design has the idea
                that a push waits for the stack to be non-full,
                and a top waits for the stack to be non-empty.

        Q: Should the notify() call be implicit when a synchronized method
                returns?
                No, the notify() has to be explicit,
                it is not done automatically by the return
                from a synchronized method (only an unlock is done by that).
                Why? so that notification is not given when methods like
                top, full, and empty are called and return... (efficiency)

        Note that this pattern essentially implements monitors
                (Hoare and Brinch-Hansen, independently),
                and resembles critical regions (of Brinch-Hansen).
                See also Andrew's book "Concurrent Programming"
                for more details.

        However, there is only a single "queue" or wait set per object,
                unlike the original version of the monitor's idea.
                This makes it more difficult to implement solutions to
                problems like reader's priority or writer's priority.

        See Bloom's MIT/LCS/TR-211 for a discusion of the expressive power
                issues.
                One example that would be hard to program with the Java
                mechanism would be a "writer's exclude others" version
                of the readers and writers problem.

** packages and privacy

*** packages
------------------------------------------
                 PACKAGES

Goals:
  


Packages contain:
     classes, interfaces,
     packages

Example:

  java
      .lang
            Object
            Integer
            ...
      .util
            BitSet
            ...
   edu
      .iastate
         BitSet
         .cs
            Dequeue
------------------------------------------
       ... prevent name conflicts
           to help make large scale development easier

        No special privilages in edu.iastate.cs to BitSet,
        just same as anything else

        Typical implementation is that each package is a directory
        on a file sys, but can also have packages stored in a database

------------------------------------------
         SYNTAX EXAMPLES

Compilation Units (types and interfaces):

 package edu.iastate.cs;

 import java.util.Vector;
 import java.lang.*;

 public abstract class ADequeue {
   private Vector rep;
   public void addToEnd(Object o);
   public void add(java.lang.Object o);
   void packageOnlyOp();
 }

------------------------------------------

        This example would have to be in edu/iastate/cs/ADequeue.java

        import java.util.Vector makes Vector in the code
           be the same as java.util.Vector (abbreviates)
        import java.lang.* is not needed, but this form
           has the effect of making all types in java.lang available,
           provided they don't conflict with other imports.

        only one class in a compilation unit can be public
                (in file-based implementations)

        names in a class (and classes and types) that aren't protected
           explicitly are accessible to other members of the package,
           but not to code in other packages.

        Q: What prevents a client from accessing packageOnlyOp by writing new
                code in the package edu.iastate.cs?

        compare to friends in C++

*** protection levels

------------------------------------------
           PROTECTION IN A CLASS

public class Point {
  protected int x, y;
  private int init_x, init_y;
  public Point(int a, int b) {
    x = a; init_x = a;
    y = b; init_y = b;
  }
  public int get_x() { return x; }
  public int get_y() { return y; }
  public void move_x(int dist) {
    x += dist;
  }
  public void move_y(int dist) {
    y += dist;
  }
  public void reset() {
    x = init_x; y = init_y;
  }
------------------------------------------

** reflection
------------------------------------------
              REFLECTION API

Goals:

 Running code can:
  - discover information about:
      - fields,
      - methods, and
      - constructors
    of loaded classes

  - operate on the objects

  - create new objects

Used by:




------------------------------------------ 
            The information includes type information, privacy, static, etc.

        ... debuggers, class browsers,
            object inspectors, interpreters, ...

            But it's expensive, so don't use it if can access objects more
                directly (e.g., Method vs. function objects)
------------------------------------------
                MECHANISM

In java.lang:
   Class
      methods: getField
               getMethod
               getConstructor

In java.lang.reflect:
   Method
   Field
   Constructor
   Member (interface)
   Modifier
------------------------------------------

        Q: What does reflection have to do to preserve type safety?
                run-time checks needed
        Q: To preserve privacy?
                run-time checks needed again
        Same for other aspects.