Java Syntax

Basic Program

//////////////////////////////////////////////////////////////////////////////
//  name: HelloWorldApp
//  purpose: stand-alone executable class (has main) that prints "hello world"
//  notes: everything in java must be inside a class (no "floating" functions)
//          traditionally each source file represents one class (with its name)
//////////////////////////////////////////////////////////////////////////////
public class HelloWorldApp
{
//////////////////////////////////////////////////////////////////////////////
//  name: main
//  purpose: entry point of the whole program
//  args: (in)  args - array of strings of command line arguments (no prog-name)
//  returns: nothing
//////////////////////////////////////////////////////////////////////////////
  public static void main(String[] args)
  {
    /* c-style remarks are also possible */
    System.out.println("hello world");
    // or do the \n ourselves c-style
    System.out.print("hello world\n");
  }
}

Basic Types

//////////////////////////////////////////////////////////////////////////////
//  name: showTypes
//  purpose: show some basic types and type operations
//  args: (in)  arg_int - must be (in), primitives are passed by value
//        (out) arg_sb - can be (out), Objects are passed by reference
//        (in)  arg_str - must be (in), String is immutable
//        (out) arg_arr - out primitives can be achieved using 1-sized arrays
//  returns: nothing
//////////////////////////////////////////////////////////////////////////////
void showTypes(int arg_int, StringBuffer arg_sb, String arg_str, int arg_arr[])
{
  // primitive types (regular c-like handling)
  byte smallest = (byte)17;   // whole signed num 1 byte size (cast needed)
  short small = (short)3365;  // whole signed num 2 byte size (cast needed)
  int num = -90999999;        // whole signed num 4 byte size (cast not needed)
  long large = 64L;           // whole signed num 8 byte size (L for long)
  float real = (float)0.01;   // real num 4 byte size (cast needed)
  double bigreal = 0.00001;   // real num 8 byte size (cast not needed)
  char letter = 'a';          // unicode character 2 byte size
  char uniletter = '\u0061';  // same as letter (both equal 'a'), unsigned
  boolean bool = false;       // either true or false
  final double pi = 3.14;     // value cannot be changed anymore (const)
  int int_arr[] = new int[9]; // allocate an empty int array with 9 elemets
  char chr_arr[] = {'h','i'}; // allocate an array an initialize it
  int ml[][] = {{1,2},{3,4}}; // multi-dimentional arrays are also possible

  // primitive type operations
  smallest++;                 // smallest now equals 18
  small -= 5;                 // small now equals 3360
  num = (20/5 + 2*3) % 3;     // num now equals 10 modulus 3 which is 1
  small = (0x1|0xf)^(0x7&0x3);// small now equals 0x0a
  small = -8 >> 3;            // small now equals -1, >>> without sign extension
  large = ~num & 0xffffffff;  // larger types and masks simulate unsigned
  bool = !bool;               // bool now equals true
  smallest = (byte)large;     // cast between types (can loose some data)
  System.out.print(number);   // print can handle all primitive types
  int_arr[0] = 33 + ml[0][0]; // c-like array access, 0 is first element
  int len = int_arr.length;   // Arrays have a length member

  // complex classy types (allocate with new, contain methods)
  String str = new String("hello");   // String is immutable (not changable)
  String hi = new String(chr_arr);    // String has many possible ctors
  String no_alloc = null;             // allocating the String is not a must
  String str_arr[] = new String[9];   // even Strings can come in arrays
  StringBuffer b = new StringBuffer();// StringBuffer is mutable (unlike String)
  b = new StringBuffer("hello");      // StringBuffer also has many ctors
  Integer integer = new Integer(237); // primitives have wrapper classes
  int i = integer.intValue();         // primitive value easily accessible

  // complex classy operations
  bool = str instanceof String;       // bool is true since str is String
  str = str + " world";               // a new String is allocated with concat
  char h = str.charAt(0);             // no str[0] access, String is no array
  int strlen = str.length();          // String has many useful methods
  int strcmp = str.compareTo("hi");   // no ==, strcmp return values (-,0,+)
  str.append("at end");               // immutable - allocates a new String
  b.append("at end");                 // mutable - tries to change current b
  str = num.toString();               // everything in java has toString method
  num = Integer.valueOf("2").intValue();      // wrapper class has conversions
  real = Float.valueOf("3.14").floatValue();  // each primitive has its own

  // arguments (pass by value, pass by reference)
  arg_int = 5;                        // caller arg is not changed (by value)
  arg_sb.append("\n");                // caller arg is changed (ref to same obj)
  arg_str = new String("new");        // new String placed in local ref only
  arg_sb = new StringBuffer("new");   // caller arg is not changed here as well
  arg_arr[0] = 5;                     // caller arr[0] is of course changed
}

Conditionals

//////////////////////////////////////////////////////////////////////////////
//  name: showConds
//  purpose: show the basic conditionals
//  args: (in)  age - the age of the viewer
//  returns: nothing
//////////////////////////////////////////////////////////////////////////////
public void showConds(int age)
{
  // vars
  int score = 0;

  // if statement
  if ((0 == age) && (age != 1)) return; // just born
  // String and comparisons
  String str1 = new String("hello");
  String str2 = new String("hello");
  if (str1 == str2) return;             // not the same references, doesn't ret
  if (!str1.equals(str2)) return;       // content isn't different, doesn't ret

  // if-else statement
  if ((age < 18) || !(age <= 80))
  {
    // not in the right age to be here
    return;
  }
  else score = 1;  // give a bonus of 1 for the right age

  // switch block, instead of many if-else blocks
  // only primitive types char,byte,short,int can be switched upon
  switch (age)
  {
    case 17:
    case 53:
      score++;              // give extra bonuses for these ages
      score = score * 2;
      break;
    default:
      score = 0;            // for all others start again from zero
  }

  // do something with the score
  handle_score(score);
}

Loops and Iterations

//////////////////////////////////////////////////////////////////////////////
//  name: showFlow
//  purpose: show some basic flow blocks
//  args: none
//  returns: total score
//////////////////////////////////////////////////////////////////////////////
public int showFlow()
{
  // vars
  int score = 0;

  // for statement
  for (int i=0; i<10; i++) score++;   // loop 10 times

  // while statement, check condition before
  int j = 3;
  while (j>0)       // loop 2 times
  {
    score++;
    j = j - 2;
  }

  // do-while statement, check condition after
  do                // loop 1 time
  {
    score++;
    j--;
  } while (j>0);

  // continue and break can help decide locally
  char ch;
  while (1)         // loop forever
  {
    ch = getInputFromUser();
    if (ch == 'q') break;         // exit the loop
    if (ch == 's') continue;      // continue to the next iteration
    score++;
  }

  return score;
}

Exceptions

//////////////////////////////////////////////////////////////////////////////
//  name: MyException
//  purpose: implement a very simple personalized exception class
//  notes: Exception < RuntimeException < ArrayIndexOutOfBoundsException
//                   < IOException < EOFException
//////////////////////////////////////////////////////////////////////////////
public class MyException extends Exception
{ public MyException(String message) { super(message); } }  // ctor only

//////////////////////////////////////////////////////////////////////////////
//  name: showExceptions
//  purpose: show some basic exception handling
//  args: none
//  returns: true on success, false on failure
//////////////////////////////////////////////////////////////////////////////
public boolean showExceptions() throws MyException // callers must handle these
{
  // vars
  boolean ok = true;

  try                   // block with "dangerous" code or API that throws
  {
      int arr[] = new int[3];
      int index = getIndexWhichIsNegativeOnFailure();
      if (index < 0) throw new MyException("Index is negative");
      arr[index]++;     // hopefully index will be < 3
  }
  catch (ArrayIndexOutOfBoundsException e)  // potential problem
  {
    ok = false;         // handle this silently (retval only)
  }
  catch (IOException e) // several allowed, catches all that derives from
  {
    System.out.println("Caught IOException " + e.toString());
    e.printStackTrace();
    throw e;            // re-throw this exception (function will exit here)
  }
  finally               // cleanup code that is guarenteed to always run
  {
    System.out.println("This will print regardless of exceptions");
  }

  return ok;
}

Classes

//////////////////////////////////////////////////////////////////////////////
//  name: MyVector
//  purpose: implement a simple class
//////////////////////////////////////////////////////////////////////////////
public class MyVector               // without public usable only in its package
{
  // members
  private static int num_created=0; // will exist regardlesss of instances
  protected float _x, _y;           // protected can be accessed by derived too

  // example of a function that can be called without an instance (static)
  public static int getNumCreated()
  {
    return this.num_created;        // access can be through this keyword
  }

  // ctor with no arguments (if emitted, caller will have to supply arguments)
  // private,protected ctor will enable appropriate class instantiation only
  public MyVector()
  {
    this(0,0);      // invoke the other ctor in this class (below)
  }

  // overloaded ctor (overloading possible with any method like in c++)
  // no default parameters possible, unlike c++
  public MyVector(float x, float y)
  {
    _x = x; _y = y; // init the members
    num_created++;  // access may have to be synchronized if multi-threaded
  }

  // regular public method to return size of the vector
  public float getSize()
  {
    return Math.sqrt(_x*_x+_y*_y);
  }
}

////////////////////////////////// usage /////////////////////////////////////
int total_num = MyVector.getNumCreated();
MyVector vec1 = new MyVector();
MyVector vec2 = new MyVector(0.23,0.98);
float vec2_size = vec2.getSize();

Derived Classes

//////////////////////////////////////////////////////////////////////////////
//  name: MyObject
//  purpose: implement an abstract class of a simple object
//  notes: you can't make instances of an abstract class
//////////////////////////////////////////////////////////////////////////////
abstract class MyObject // not public, only classes in this package can use
{                       // class without extends actually extends lang.Object
  // members
  private float _weight;

  // ctor (note that no no-param ctor exists)
  // emitting a ctor will create a default empty no-param ctor
  public MyObject(float weight)
  {
    _weight = weight;
  }

  // declaration only, must be implemented in derived (virtual by default)
  public abstract void printName();

  // non-virtual method, cannot be overriden in derived (also faster to call)
  //  by default, all methods are virtual (ptr to base will call derived method)
  public final float getWeight()
  {
    return _weight;
  }
}

//////////////////////////////////////////////////////////////////////////////
//  name: Soap
//  purpose: implement a simple derived class (throwable branded soap)
//  notes: only ctors are called in chains (overriden methods aren't)
//////////////////////////////////////////////////////////////////////////////
public final class Soap // final means this class cannot be subclassed (faster)
  extends MyObject      // derived from MyObject, no multiple inheritence
{
  // members
  private final String _brand;  // cannot be changed in runtime, ctor must init
  protected MyVector _speed;

  // ctor (note that no no-param ctor exists)
  public Soap(String brand)
  {
    super(1.33);  // parent ctor must be first line, if emitted calls no-param
    _brand = new String(brand); // since final must be initialized here
  }

  // implementation of abstract printName
  public void printName()
  {
    System.out.print("Soap produced by " + _brand + " which weighs ");
    System.out.println(super.getWeight());  // calls explicitly parent method
  }

  // theoretically called by garbage-collector when object is freed
  // when or if it will run is not promised(!) - refrain from using it
  protected void finalize() throws Throwable
  {
    super.finalize(); // unlike c++ dtor, parent's finalize is called manually
  }
}

////////////////////////////////// usage /////////////////////////////////////
Soap my_soap = new Soap("Gillette");
float weight = my_soap.getWeight(); // calls MyObject implementation
MyObject my_obj = new Soap("Fa");
my_obj.printName();                 // calls Soap implementation (polymorphism)

Interfaces and Packages

// package name should be included in start of every source file
// if emitted, all classes / interfaces are declared globally
package com.chiquita;

//////////////////////////////////////////////////////////////////////////////
//  name: Edible
//  purpose: declare an interface (of an object available for eating)
//  notes: interface can use extends to inherit from multiple super-interfaces
//////////////////////////////////////////////////////////////////////////////
public interface Edible
{
  // can include related constants
  final String goodTaste = "yummi";
  final String badTaste = "icky";
//////////////////////////////////////////////////////////////////////////////
//  name: eat
//  purpose: implement the process of eating the object
//  args: none
//  returns: a description of how it tasted
//////////////////////////////////////////////////////////////////////////////
  String eat();
}

//////////////////////////////////////////////////////////////////////////////
//  name: Banana
//  purpose: implement an interface
//  notes: interface can use extends to inherit from multiple super-interfaces
//////////////////////////////////////////////////////////////////////////////
public class Banana implements Edible // can implement several interfaces
{
  // eat method declared in the interface Edible
  public String eat()
  {
    // must peel it first
    if (this.state != "peeled") peelBanana();

    // do the actual eating
    while (this.state != "gone")
    {
      takeBite();
      chewAndSwallow();
    }

    // how can you not love a banana?
    return goodTaste;
  }
}

////////////////////////////////// usage /////////////////////////////////////
import com.chiquita.*;
Banana my_banana = new Banana();
System.out.println(my_banana.eat());

Threads and Synchronization

import java.io.*;                                       // for file operation

//////////////////////////////////////////////////////////////////////////////
//  name: MultiThreadedInt
//  purpose: implement an integer object safe for multi-threaded use
//////////////////////////////////////////////////////////////////////////////
public class MultiThreadedInt
{
  // members
  private int _value;
  private FileWriter logFile;

  // simple ctor
  public MultiThreadedInt(int value) throws IOException // for file operation
  {
    _value = value;
    logFile = new FileWriter("log.txt");
  }
  // synchronizes on class instance, threads will call this func one by one
  public synchronized void setValue(int value)
  {
    _value = value;
  }
  // also syncs on class instance, so is synched with setValue too
  public synchronized int getValue()
  {
    return _value;
  }
  // we don't want to synchronize on class instance (overhead)
  public void logString(String msg) throws IOException  // for file operation
  {
    // enough to sync on a specific object
    synchronized (logFile)  // this block is not synced with getValue,setValue
    {
      logFile.write(msg);
    }
  }
}

//////////////////////////////////////////////////////////////////////////////
//  name: MyThread
//  purpose: implement a simple thread
//////////////////////////////////////////////////////////////////////////////
public class MyThread extends Thread
{
  // override the run method with the thread actual body
  public void run()
  {
    // just loop meaninglessly
    for (int i = 0; i < 10; i++)
    {
        System.out.println(i);
        try { sleep((long)(Math.random() * 1000)); }
        catch (InterruptedException e) {}
    }
  }
}

////////////////////////////////// usage /////////////////////////////////////
new MyThread().start();

Collections

import java.util.*;

//////////////////////////////////////////////////////////////////////////////
//  name: showCollections
//  purpose: show use of the handy collection classes
//  args: none
//  returns: nothing
//////////////////////////////////////////////////////////////////////////////
public void showCollections()
{
  // vars
  String str = new String("hello");
  Integer num = new Integer(17);
  Object obj = null;
  int size;

  // good practice to work with collections through abstract interfaces only
  //  this enables later hassle-free implementation changes (even to 3rd party)

  // ArrayList - ordered sequence, unlike a regular array this is resizable
  List al = new ArrayList(500); // initial capacity           // unsynchronized
  List sal = Collections.synchronizedList(new ArrayList(500));// synchronized
  size = al.size();             // num of objects stored in the collection (O1)
  if (!al.isEmpty()) al.clear;  // check if not empty (O1) and empty collection
  al.add(num);                  // add Integer num to end (O1)
  al.add(0,"first");            // add String "first" at index 0 (0n)
  obj = al.get(1);              // obj is reference to String "first" (O1)
  al.set(0,new Integer(88));    // change Object at index 0 to Integer 88 (O1)
  al.remove(0);                 // remove Object at index 0 (On)

  // HashSet - a group that cannot contain duplicates
  Set hs = new HashSet(500);    // initial capacity           // unsynchronized
  Set shs = Collections.synchronizedSet(new HashSet(500));    // synchronized
  size = hs.size();             // num of objects stored in the collection (O1)
  if (!hs.isEmpty()) hs.clear;  // check if not empty (O1) and empty collection
  hs.add(num);                  // add Integer num, no order, no dups (O1)
  if (!hs.contains("hello"))    // compares Objects using equals() method (O1)
    hs.add(str);                // add String str ("hello") (O1)
  hs.remove("hello");           // remove String "hello" (O1)

  // HashMap - a key-value coupling that cannot contain duplicates
  Map hm = new HashMap(500);    // initial capacity           // unsynchronized
  Map shm = Collections.synchronizedMap(new HashMap(500));    // synchronized
  size = hm.size();             // num of objects stored in the collection (O1)
  if (!hm.isEmpty()) hm.clear;  // check if not empty (O1) and empty collection
  hm.put(num, "jim");           // add key Integer num with value String (O1)
  obj = hm.get(new Integer(17));// obj is reference to value String "jim" (O1)
  if (!hm.containsKey("key"))   // compares Objects using equals() method (O1)
    hm.put("key", str);         // add key String "key" with value String str
  hm.remove("key");             // remove key-value pair of key "key" (O1)
  Set keys = hm.keySet();       // changes to Set keys will be reflected in hm
}