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 = (0×1|0xf)^(0×7&0×3);// small now equals 0×0a
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
}
