The Java Language:

    // This is a comment
    /* This is a comment */
    /** This is a comment */

    /* Ignore this code...
       i = 3;
       j = 4;   /* This is a comment */
       k = 5;
    */

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

    null
    true
    false

    boolean
    char       16-bit Unicode character
    byte       8-bit integer
    short      16-bit integer
    int        32-bit integer
    long       64-bit integer
    float      32-bit floating point
    double     64-bit floating point

    Byte.MIN_VALUE
    Byte.MAX_VALUE

    Short.MIN_VALUE
    Short.MAX_VALUE

    Integer.MIN_VALUE
    Integer.MAX_VALUE

    Long.MIN_VALUE
    Long.MAX_VALUE

    Float.MIN_VALUE
    Float.MAX_VALUE
    Float.Nan
    Float.NEGATIVE_INFINITY
    Float.POSITIVE_INFINITY

    Double.MIN_VALUE
    Double.MAX_VALUE
    Double.Nan
    Double.NEGATIVE_INFINITY
    Double.POSITIVE_INFINITY

    !            Logical negation
    ==  !=       Equal, not-equal
    &  |  ^      Logical "and," "or," and "exclusive-or"
                     (both operands evaluated)
    && ||        Logical "and" and "or"
                     (short-circuit evaluation)
    ?:           Ternary conditional operator
    =            Assignment
    &=  |=  ^=   The operation, followed by assignment

    123   Decimal notation
    0x7b  Hexadecimal notation
    0X7B  Hexadecimal notation (case is insignificant)
    0173  Leading zero indicates octal notation

    byte   8-bits
    short  16-bits
    int    32-bits
    long   64-bits

    34.
    3.4e1
    .34E2

    float  32-bits
    double 64-bits

    12.34f
    12.34F
    12.34d
    12.34D

    expr++  expr--   Post-increment, post-decrement
    ++expr  --expr   Pre-increment, pre-decrement
    -expr   +expr    Unary negation, unary positive
    +  -  *          Addition, subtraction, multiplication
    /                Division
    %                Remainder
    <<  >>  >>>      Shift-left, shift-right-arithmetic,
                        shift-right-logical
    <  >  <=  >=     Relational
    ==  !=           Equal, not-equal
    =                Simple assignment
    += -+ *= /= %=   The operation, followed by assignment
      <<= >>= >>>=

    'a'
    '\n'

    \n     newline
    \t     tab
    \b     backspace
    \r     return
    \f     form-feed
    \\ 
    \' 
    \" 
    \DDD   octal specification of a character
             (\000 through \377 only)
    \uXXXX hexadecimal specification of a Unicode character

    x = (int) y;

   char --> short
   byte --> short
   short--> int
   int --> long
   long --> float
   float --> double

    byte x, y, z;
    ...
    x = y + z;        // Will not compile

    x = (byte) (y + z);

    y=127;
    z=127;
    x = (byte) (y + z);

    int x, y, z;
    y=2147483647;
    z=2147483647;
    x = y + z;

    int i = ...;
    System.out.println ("The value is " + i);

    System.out.println ("The value is " + i.toString() );

    anInt = (int) aLong;

    Person p;

    Person p;
    Student s;
    ...
    p = s;            // No cast necessary.
    ...
    s = (Student) p;  // Explicit cast is necessary

    p = s;

    s = (Student) p;

    s = (Student) p;

    if (p instanceof Student) {
      s = p;
    } else {
      throw new ClassCastException ();
    }

    x = 123;

    if (x = 0) ...;

    Person p, q;
    ...
    if (p == q) ...;

    String s, t;
    s = "abc" + "xyz";
    if (s == "abcxyz") ...;
    if (s.equals ("abcxyz")) ...;

    if (double.Nan == double.Nan) ...;

    Person p = ...;
    ...
    if (p instanceof Student) ...;

    struct MyType { ... };     // "C/C++" language
    MyTpye *p, *q;
    ...
    (*p).field = (*q).field;   // Get from memory & store into memory
    ...
    p = q;                     // Copy the pointer
    ...
    if (p == q) ...            // Compare pointers
    ...
    if (*p == *q) ...          // Compare two structs

    class MyType { ... };      // Java language
    MyTpye p, q;
    ...
    p.field = q.field;         // Get from memory & store into memory
    ...
    p = q;                     // Copy the pointer
    ...
    if (p == q) ...            // Compare pointers
    ...
    if (p.equals(q)) ...       // Compare two objects

    p = (MyType *) 0x0034abcd; // "C/C++" language
    (*p).field = ...;          // Move into arbitrary memory location

    highest    []  .  (params)  expr++  expr--
               ++expr   --expr   +expr   -expr  ~  !
               new  (type)expr
               *  /  %
               +  -
               <<  >>  >>>
               <  >  <=  >=  instanceof
               ==  !=
               &
               ^ 
               |
               &&
               ||
               ?:
    lowest     =  +=  -=  *=  /=  %=  <<=  >>=  >>>=  &=  ^=  |=

    a = b = c;

    a = (b = c);

    ==  !=       Identity testing (i.e., pointer comparison)
    /            Integer division: truncates toward zero
                     -7/2 == -3
    %            Remainder after /
                     (x/y)*y + x%y == x
                     -7%2 == -1
    []           Array indexing
    .            Member accessing
    (params)     Message sending
    &  |  ^  !   Logical AND, OR, XOR, and NOT (valid on boolean values)
    &  |  ^  ~   Bitwise AND, OR, XOR, and NOT (valid on integer and
                     char values)
    <<  >>  >>>  Shift bits (SLL, SRA, SRL)
    &&  ||       Boolean only, will evaluate second operand only if necessary
    ?:           Boolean-expr ? then-value : else-value
    (type)expr       Explicit type cast
    +            Numeric addition and String concatenation

    x = y + 5;
    a = b = c = -1;    // Multiple assignment is ok

    p.addDependent (a,b,c);

    i++;
    j--;
    ++i;   // same as i++;
    --j;   // same as j--;

    new Person ("Thomas", "Green");

    while (boolean-condition) statement;

    for (i=0,j=100; i<5; i++,j--) statement;

    do statement while (boolean-condition);

    while (boolean-condition) {
      statement;
      statement;
      statement;
    }
    for (i=0; i<5; i++) {
      statement;
      statement;
      statement;
    }
    do {
      statement;
      statement;
      statement;
    } while (boolean-condition);

    switch (integer-expression) {
      case 23:
        statement;
        statement;
        break;
      case 45:
        statement;
        statement;
        break;
      case 51:
      case 52:
      case 53:
        statement;
        statement;
        break;
      default :
        statement;
        statement;
        break;
    }

             while (condition-1) {
    my_loop:   while (condition-2) {
                 while (condition-3) {
                   ...
                   break my_loop;
                   ...
                   continue my_loop;
                   ...
                 }
               }
             }

    return;
    return expression;

    if (boolean-expression)
      statement-1;
    else
      statement-2;

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

    Person [] p;

    new Person [10]

    Person [] p = new Person [10];

    p[0], p[1], p[2], ... , p[9]

    Person p [] = new Person [10];

    Person [] p = new Person [10];
    for (int i = 0; i < p.length; i++) {
      p[i] = new Person(...);
    }

    p.length

    p[i] = p[j];

    int [] [] a = { {1, 2}, {4, 5, 6}, {3}};

    int [] a = {1, 2, 3, 4, 5, 6, };   // extra comma at end is optional

    int [] [] a = {
                    {1, 1, 4, 1, 1, 1},
                    {1, 1, 5, 1, 1, 1},
                    {1, 1, 6, 1, 1, 1},
                  };

    String x = "hello"; 

    System.out.print (x);
    System.out.println (x);   // Follows it with a newline

    x = x + " there";
    System.out.println (x + " everyone!");

    int i = ...;

    System.out.println ("The value is " + i);

    System.out.println ("The value is " + (i.toString()));

    x.length

    x.length () --> int
    x.charAt (int) --> char
    x.indexOf (char) --> int
    x.equals (String) --> boolean
    x.equalsIgnoreCase (String) --> boolean
    x.startsWith (prefixString) --> boolean
    x.endsWith (suffixString) --> boolean
    x.compareTo (String) --> -1,0,+1
    x.substring (startPos,endPos) --> String
    x.toLowerCase () --> String
    x.toUpperCase () --> String
    x + y --> String
    x.toCharArray () --> char[]

    String s1 = ...;
    String s2 = ...;
    ...
    if (s1 == s2) {
      // both point to the same object
    }

    if (s1.equals(s2)) {
      // both contain the same character sequence
    }

    StringBuffer (String) --> StringBuffer
    StringBuffer (initCapacity) --> StringBuffer
    StringBuffer () --> StringBuffer

    StringBuffer x, y;
    x.append (y) --> StringBuffer
    x.setCharAt (int,char) --> void
    x.setLength (int) --> void

    public class Person {
      String first;
      String last;
      int age;
      static int total = 0;
      Person (String f, String l, int a) {
        first = f;
        last = l;
        age = a;
        total++;
      }
      String getName () {
        return last + ", " + first;
      }
      void setName (String f, String l) {
        first = f;
        last = l;
      }
      static int getCount () {
        return total;
      }
    }

    public
    abstract
    final
    strictfp

    Person p;
    p = new Person ("Harry", "Porter", 50);

    Person p = new Person ("Harry", "Porter", 50);

    public class Person {
       ...
      Person () {
        first = "John";
        last = "Doe";
        age = 0;
        total ++;
      }
      ...
    }

    Person p = new Person ();

    grp5.addToGroup (new Person ("Susan", "Brown", 20), "President");

    OutOfMemoryError

    interface MyInter extends OtherInterA, OtherInterB, OtherInterC {
      int foo (...);
      int bar (...);
      ...
      int x = 123;
      double pi = 3.1415;
    }

    void myFunct (int a, char ch);                           // message
    ...
    void myFunct (int a, char ch) { ... statements ... }     // method

    interface TaxableEntity {
      String getName ();
      int getID ();
      int computeTax (int year);
    }

    class Person implements TaxableEntity {
      ...
      String getName () { ... }
      int getID () { ... }
      int computeTax (int year) { ... }
      ...
    }
    class Corporation implements TaxableEntity {
      ...
      String getName () { ... }
      int getID () { ... }
      int computeTax (int year) { ... }
      ...
    }

    int i = 1;
    int j = 2;
    int k = 3;

    int i = 1, j = 2, k = 3;

    int i, j, k;

    local variables in methods
    normal fields in classes
    static fields in classes (class variables)
    final fields (constants in classes and interfaces)

    class MyClass {
      int x;            // initialized to default of 0
      int y = 47;
      ...
    }

    boolean              false
    char                 \u0000  16-bit Unicode character
    byte                 0       8-bit integer
    short                0       16-bit integer
    int                  0       32-bit integer
    long                 0       64-bit integer
    float                0.0     32-bit floating point
    double               0.0     64-bit floating point
    <object reference>   null    pointer to an object

    int x = 2 * a.foo (b, c);

    public static volatile Person [] [] x, y, z = ... ;

    <type> <var> = <expr>;

    int i = 0;

    - primitive types (like int)
    - classes (like Person)
    - interfaces (like TaxableEntity)

    TaxableEntity t;

    t = new Person (...);

    interface TaxableEntity {
      public static final void foo (...);  
      ^^^^^^ ^^^^^^ ^^^^^                  // Syntax error here
      ...
      private float = 3.1415; 
      ^^^^^^^                              // Syntax error here
    }

    class Person implements TaxableEntity, AnimateThing, GraphicObj {
      ...
    }

    ... a + (5 * TaxableEntity.pi) + b ...

    TaxableEntity t;
    ...
    ... a + (5 * t.pi) + b ...     // Not recommended

    public void finalize () throws Throwable {
      ...
    }

    super.finalize();

    x = p.first;
    p.last = "Smith";

    class Person {
      ...
      String getName () {
        return last + ", " + first;
      }
    }

    class MyClass {
      ...
      void myMethod () {
        ...
        this.field = ...;
        ...
        ... this.field ...
        ...
      }
    }

    class MyClass {
      ...
      void myMethod () {
        ...
        field = ...;
        ...
        ... field ...
        ...
      }
    }

    class Student extends Person {
      ...
    }

    class Employee extends Person {
      ...
    }

    ...super.field...

    Student s = ...;
    ...s.field...       // gets the new Student field

    Person p = s;
    ...p.field...       // gets the hidden Person field

    "public visibility"
    "protected visibility"
    "package visibility" (the default)
    "private visibility"

    class Person {
      protected int field;
      ...
    }
    class Student extends Person {
      ...
    }
    class Employee extends Person {
      ...
    }

    x.field

    p.setName ("Thomas", "Green");

    x.foo (a, b, c);
    x.bar ();

    y = x.myMeth ();
    y = x.myField;

    (x.bar()) . setName ( "Sue"+"Ann", y.computeLast(a,b,c) );

    x.bar().setName("Sue"+"Ann", y.computeLast(a,b,c));

    x.foo (a, b, c);

    Person x;

    Student s =  ...;
    x = s;

    x.foo (a, b, c);

    class Person {
      void foo (...) { ...}
       ...
    }
    class Student extends Person {
      void foo (...) { ...}
      ...
    }

    class Person {
      void foo (...) {
        ...
        this.bar (...);
        ...
      }
    }

    class Person {
      void foo (...) {
        ...
        bar (...);
        ...
      }
    }

    x.foo (i);
    ...
    void foo (int a) {
      a = 5;               // OK.  Will not modify i.
    }

    Person p = ...;
    x.foo2 (p);
    ...
    void foo2 (Person a) {
      a.setName ("Thomas");
    }

    class Person {
      ...
      void foo () {
        ...
        this.anotherMessage ();
        ...
      }
      ...
    }

    this.foo (a,y,z)
    foo (x,y,z)            // equivalent

    class Student extends Person {
      ...
      void foo () {         // overrides the inherited version
        ...
        foo ();             // invoke this method, recursively
        ...
        super.foo ();       // invoke the overridden version
        ...
        super.bar ();
        ...
      }
      ...
    }

    void foo () {
      super.foo ();
      ...
    }

    int i = Person.getCount();

    Person p =  ...;
    int i = p.getCount();

    Person.getCount();

    p.getCount();

    class Person {
      ...
      void foo () {
        ...
      }
      void foo (int i) {
        ...
      }
      void foo (String s) {
        ...
      }
      ...
    }

    super.name
    Person.name

    x.name

    Person p = ...;
    Student s = ...;
    ...
    p.name   // Gets the field from the superclass, regardless
             //      of what p points to at run-time.
    s.name   // Gets the field from the subclass.

    final void foo (...) {
      ...
    }

    final class MyClass {
      ...
    }

    class MyClass implements MyInterface {
      ...
    }

    MyInterface x;
    x = new MyClass (...);

    x = new MyInterface { ... fields and methods ...};

    x = new MySuperClass { ... fields and methods ...};

    x = new MySuperClass (a,b,c) { ... fields and methods ...};

    public static void

    class Echo {
      public static void main (String[] args) {
        System.out.println("Welcome!");
        for (int i = 0; i<args.length; i++) {
          System.out.print (args[i] + " ");
        }
        System.out.println();
      }
    }

    % java Echo hello there folks
    Welcome!
    hello there folks
    % ...

    if (x == y) ...;
    if (x != y) ...;

    x == y --> boolean
    x != y --> boolean

    x.equals (Object obj) --> boolean
    x.hashCode ()--> int
    x.clone ()--> Object (throws CloneNotSupportedException)
    x.getClass ()--> Class
    x.finalize ()--> void (throws Throwable)
    x.toString ()--> String

    class MyClass ... implements Cloneable {
      ...
      public Object clone() throws CloneNotSupportedException {
        return super.clone();
      }
      ...
    }

    MyClass x, y ...;
    ...
    y = (MyClass) x.clone();

    MySupertype x;
    MySubtype y;
    ...
    y = (MySubtype) x;

    x.foo()
    x.field
    x[i]

    class MyClass {
      static final double pi = 3.14159;
      ...
    }

    interface MyInterface {
      double pi = 3.14159;
      ...
    }

    area = dia * pi;            // within MyClass
    area = dia * MyClass.pi;    // anywhere else

    abstract class MyAbstractClass {
      ...
      public void foo () { ... }   // Normal method
      abstract void bar ();        // Abstract method
      ...
    }

    MyAbstractClass x;
    x = new MyAbstractClass ();    // Compiler error here
    ...
    x.foo ();                      //   ...this method doesn't exist.

    class MySub extends MyAbstractClass {
      ...
      // foo is inherited
      void bar () { ... }          // An implementation is given for bar
      ...
    }

    MyAbstractClass x;
    ...
    x = new MySub ();
    ...
    x.foo ();                      // An implementation will exist

    class MySuper {
      ...
      public void bar () { ... }
      ...
    }

    abstract class MySub extends MySuper {
      ...
      abstract void bar ();
      ...
    }

    ArrayIndexOutOfBoundsException
    NullPointerException
    ClassCastException

    x = a[i+1];

    throw new MyExcept ();

    ArrayIndexOutOfBoundsException
    NullPointerException
    ...

    class MyExcept extends Exception {
      ...
    }

    try {
      statements
    } catch (SomeException e) {
      statements
    } catch (MyExcept e) {
      statements
    } catch (YetAnotherException e) {
      statements
    ...
    } finally {
      statements
    }

    throw new MyExcept ();

    } catch (MyExcept e) {
      statements...           // may use "e" here
    }

    class MyExcept extends Exception {
      String severity;
      MyExcept (String s) { severity = s; }
      ...
    }


    try {
      ...
      throw new MyExcept ("Mission-Critical");
      ...
    } catch (MyExcept e) {
      ... use e.severity here ...
    }

    try {
      ...
        try {
          ...
          throw ...;
          ...
        } catch (...) {
          statements
        } catch (...) {
          statements
        ...
        }
      ...
    } catch (...) {
      statements
    } catch (...) {
      statements
    ...
    }

    bar () {
      ...
        try {
          ...
          x.foo ();
          ...
        } catch (...) {
          statements
        } catch (...) {
          statements
        ...
        }
      ...
    }

    foo () {
      ...
        try {
          ...
          throw ...;
          ...
        } catch (...) {
          statements
        } catch (...) {
          statements
        ...
        }
      ...
    }

    - normal completion (i.e., execution falls out the bottom
          of the "body statements")
    - a return statement is executed
    - an exception is thrown

    - normal completion (i.e., execution falls out the bottom
          of the catch statements)
    - a return statement is executed
    - another exception is thrown within the catch statements

    - normal completion of the body or a catch clause
    - the execution of a return statement in the body or a catch clause
    - the result of an uncaught exception in the body
    - the result of a exception getting thrown in some catch clause

    - normal completion (i.e., execution falls out the bottom
          of the finally statements)
    - a return statement is executed in the finally statements
    - another exception is thrown within the finally statements

    Object
      ...
      Throwable
        Exception
          <User Defined Exception #1>
          <User Defined Exception #2>
          <User Defined Exception #3>
          ...
          RuntimeException
            ArithmeticException
            ArrayStoreException
            ClassCastException
            ConcurrentModificationException
            EmptyStackException
            IllegalArgumentException
              IllegalThreadStateException
              NumberFormatException
            IllegalMonitorStateException
            IllegalStateException
            IndexOutOfBoundsException
              ArrayIndexOutOfBoundsException
              StringIndexOutOfBoundsException
            MissingResourceException
            NegativeArraySizeException
            NoSuchElementException
            NullPointerException
            SecurityException
            UndeclaredThrowableException
            UnsupportedOperationException
        Error
          LinkageError
            ClassCircularityError
            ClassFormatError
              UnsupportedClassVersionError
            ExceptionInitializerError
            IncompatibleClassChangeError
              AbstractMethodError
              IllegalAccesError
              InstantiationError
              NoSuchFieldError
              NoSuchMethodError
            NoClassDefFoundError
            UnsatisfiedLinkError
            VerifyError
          ThreadDeath
          VirtualMachineError
            InternalError
            OutOfMemoryError
            StackOverflowError
            UnknownError

    public void foo (...) 
           throws MyExcept, AnotherExcept, YetAnotherException
      {
        ...
        throw new myExcept (...);
        ...
        anotherMethod (...);
        ...
      }

    public void bar (...) 
           throws YetAnotherException
      {
        ...
        try {
          ... foo (...) ...
        } catch (MyExcept e) {
          ...
        } catch (AnotherExcept e) {
          ...
        }
      }

    ArrayIndexOutOfBoundsException
    NullPointerException
    NoSuchElementException

    InternalError
    OutOfMemoryError
    StackOverflowError

    class MyClass {
      ...
      foo () { ... statements ... }
      ...
      { ... statements ... }
      ...
    }

    class Person {
      static int personCount = 0;
      Person () { ... statements ... }
      Person (String name) { ... statements ... }
      { personCount++; }
      ...
    }

    class MyClass {
      ...
      static { ... statements ... }
      ...
    }

    class MyClass {
      ...
      static { ... statements-1 ... }
      ...
      static int x = ...;
      ...
      static { ... statements-2 ... }
      ...
      static int y = ...;
      ...
      static { ... statements-3 ... }
      ...
    }

    statements-1
    x's initialization expression
    statements-2
    y's initialization expression
    statements-3

    Number
      Byte
      Short
      Integer
      Long
      Float
      Double
    Boolean
    Character
    Void

    Integer i = new Integer (123);
    ...
    Object x = i;

    int j = i.intValue ();

    new Byte (byte) --> Byte
    new Short (short) --> Short
    new Integer (int) --> Integer
    new Long (long) --> Long
    new Float (float) --> Float
    new Double (double) --> Double
    new Boolean (boolean) --> Boolean
    new Character (char) --> Character

    x.byteValue (Byte) --> byte
    x.shortValue (Short) --> short
    x.intValue (Integer) --> int
    x.longValue (Long) --> long
    x.floatValue (Float) --> float
    x.doubleValue (Double) --> double
    x.booleanValue (Boolean) --> boolean
    x.charValue (Character) --> char

    char   Character 
    int    Integer

    java.lang    Essential classes;  always imported automatically
    java.io      Basic I/O (files and character streams)
    java.util    Data structure classes
    java.awt     "Abstract Windowing Toolkit" (user interface classes)
    java.net     Sockets, TCP/IP, and URL classes
    java.applet  Running Java programs over WWW and internet browsers

    package x.y.z;

    package com.sun.games;

    java.util.Date d = new java.util.Date ();

    import java.util.Date;  // to import a single class or interface
    import java.util.*;     // to import everything in the package

    Date d = new Date ();

    public class MyThread extends Thread {
      public void run () {
        ... statements ...
      }
      ...
    }

    Thread t = new Thread ();

    t.start ();

    Thread.currentThread () --> Thread

    aThread.sleep (long milliseconds) --> void

    Thread.yield () --> void

    aThread.join () --> void

    aThread.setName (String name) --> void
    aThread.setPriority (int pri) --> void
    aThread.getName () --> String
    aThread.getPriority () --> int

    synchronized (expression) {
      ... statements ...
    }

    x.wait () --> void
    x.notify () --> void
    x.notifyAll () --> void

    synchronized void doWhenCondition () {
      while (!condition) {
        wait ();
      }
      ... Do what must be done when condition is true ...
    }


    synchronized void changeCondition () {
      ... Change some value that may be used in the condition test ...
      notifyAll ();
    }

    (x * y) * z   (   x * (y * z)