Java Basics

These are my personal notes that I use as a quick help in my work.
You are welcome to read them.

char c, cc;

'\t' tab           '\u????' unicode character
'\n' newline       '\'' single quote
'\r' return        '\"' double quote
'\r\n' CR-LF       '\\' backslash
'\f' form feed     '\b' backspace

Use double quotes!
Note capital S in String
StringBuffer is for string manipulations

Floating point:
float       // 32 bits
double      // 64 bits

class Date
  {int day;
   int month;
   int year;}

Date one_date;         // does not assign space
one_date = new Date(); // constructor

one_date.year = 2003;  // assigning to one member

Aggregate data types

Declaration does not assign space: use the constructor
This is also necessary for String

Wrapper classes

To each type corresponds a class
Note first letter is upper case
Note Integer for int, Character for char

aString.equals(anotherString) --> true or false
aString.toUpperCase() / aString.toLowerCase()

DecimalFormat df = new DecimalFormat("pattern{;pattern}");
df.format( double ) --> String
###,###.###      --> 123,456.789 0.123
###.##% 12.3%    --> (0.123)
000000.000       --> 000123.450
$###,###.### CHF --> $12,345.67 CHF
###.#####E000    --> 12.34567E003

Locale cl = new Locale("en", "US");
DecimalFormatSymbols dfs = new DecimalFormatSymbols(cl);
dfs.setDecimalSeparator('.');
dfs.setGroupingSeparator('\'');
DecimalFormat df = new DecimalFormat("pattern", dfs);
df.setGroupingSize(4);

pattern: {prefix}#,##0.##{suffix}
(or {p}0,000.000{s})
prefix/suffix is a string
% --> multiply by 100 and show '%'
E --> exponent

DecimalFormat is overloaded

ClassName new_variable_name;

Declaration

new_variable_name = new ClassName(parameters);

Instantiation and initialization (the constructor initializes the object)

char cc[];    char[] cc;
cc = new char[20];

Declares array. The two syntaxes are equivalent, although char[] is preferred.
Then create the array (initialized to zero character).

Date d[];     Date [] d;
d = new Date[10];
d[0] = new Date();
d[1] = new Date();

Declare the array
and create the array (each element is null),
then create each object!
Once the array is created, you cannot add elements.

import java.util.*;
ArrayList<String> list = new ArrayList<String>();

import java.util.*;
ArrayList<String> list = new ArrayList<String>(100);

Declares array list. Name of underlying object between < and >. (called generics)
Older versions of java: ArrayList list = new ArrayList();

It is possible to give a size at creation (here 100). It is a hint, and more elements can be created.

list.add(...)
list.get(...)
list.contains(...)      list.indexOf(...)
list.remove(...)
list.size()

Add an element, get an element, test if element is in the list, remove, get number of elements

for (UnderlyingClass v : list) { ... }

Loop through the class

Collections.sort(list)

Sort using the collections class, which is also part of java.util

import java.util.*;
HashMap map = new HashMap();
HashMap<String, Long> map = new HashMap<>();

import java.util.*;
HashMap map = new HashMap(40, 0.6F);

Declares hash map. Put generics between < and >: the first is the key and the second is the value.

It is possible to give the number of buckets at creation (here 40), and the load factor, which is the percentage of capacity at which new buckets are automatically created.

m.put(aKey, aValue);
m.get(aKey);
m.getOrDefault(aKey, aDefault);
m.containsKey(aKey);
m.containsValue(aValue);
m.size()
m.entrySet()

Adds a key-value pair, get a value based on the key (returning null if not found), get a value or use default, test for existence of a key or a value, return the number of elements, returns set of entries (for loops, use Set class in java.util) .

for (Map.Entry<String, Long> entry : m.entrySet()) {
    String theKey = entry.getKey();
    Long theValue = entre.getValue();
}

Adds a key-value pair, get a value based on the key (returning null if not found), get a value or use default, test for existence of a key or a value, return the number of elements, returns set of entries (for loops, use Set class in java.util) .

<<  drop <--  10101010000 <--0
>>    sign--> SSSS0101010  --> drop
>>>      0--> 00000101010  --> drop

Note that operand is modulo 32, so x<<32 is same as x<<0

do {
  ...
  break;
  ...
} while (boolean expr);

Throw --> catch if you can, otherwise the program terminates

Error --> let program terminate
Runtime --> useful during debug
Others --> handle (the compiler won't let you forget)

Exception is in java.lang, therefore an import statement is not necessary

try {
  //protected code
} catch (TheException e) {
  // code to handle exception e
  System.out.println(e.toString);
} catch (AnotherException | YetAnotherException e) {
  // more code
} catch (Exception e) {
  System.err.println(e.getMessage());
  // generic handle, but too general to be useful
} finally {
  // code that is always executed
  // typically close objects if open
  // (except in case of System.exit)
}

Examples:

ArithmeticException
NullPointerException
ClassCastException
NegativeArriySizeException
ArrayIndexOutOfBoundsException

TheException and AnotherException are throwable objects

Multiple exceptions separated by "|" (pipe)

public class MyException extends Exception { }

class another
...
try {
... throw new MyException (); ...
} catch(myException e) {...}   

oneMethod {
  try {
    anotherMethod();
  } catch (AnException) {
    doErrorProcessing;
  } catch (AnotherException) {
    doErrorProcessing;
  }
}
anotherMethod throws AnException, AnotherException {
  thirdMethod();
}
thirdMethod throws AnException {
   ... // some treatment that can cause AnException
}

Rule "declare or handle": either use a "try{}catch(){}" block or put in declaration (as on left) so that calling method can handle.

The compiler checks that some exceptions are handled: these are checked exceptions. Others are runtime exceptions and the compiler will not complain if there is no handler.

Constructor method has exactly the same name as the class; it cannot return a value (do not put void).

If the constructor is
  public --> all classes can create an instance;
  private --> ??
  protected --> only subclasses and classes in package
  (no specifier) --> only classes in package

Overloading the constructor name is possible. Use "this" to refer to one of the constructor methods when within the class. Use super(...) in the constructor of a subclass

Method declaration:
access level = public, private, ...
modifiers = static, abstract, final, native, synchronized
return_type: put void if none

Arguments are always passed by value. For reference types, the reference cannot be modified, but the object's values can be (i.e. the values to which the reference points). Classes are reference type objects.

If arguments have same name as the class's member variables, then they "hide" the member variables. Use "this." to refer to class members. Note that hiding is error-prone.

<access level> static aMethod(args)

static {
  ... // use to initialize static variables
}

<access level> abstract class ... {
  public abstract ... ( args ); // no body
  public ... (); { /* non-abstract method */ }
}

public class StandardClass ...

public class MyClass extends StandardClass ...
public class MySecondClass extends StandardClass ...

public class StandardClass {
  public String Display () {
  ...
  }
}

public class MyClass extends StandardClass {
  public MyClass () { \\ constructor
    super(...);
  }
  public String Display () {
    return super.Display + "more details"
  }

Methods with the same name, return type and arguments override the methods of the parent class. The runtime type of the object determines which method is used.

Note that subclass variables with the same name hide those of the superclass. Access hidden variable with "super.".

Use "super." to reference a method of the parent class (or of the ancestor class). Refer to the parent constructor by using "super()" as the first statement in the constructor.

An overriding method cannot be less accessible that the parent's method e.g. a private method cannot override a public method. And an overriding method cannot throw more exceptions than the method that it overrides.

Final methods cannot be overridden. Static methods can be hidden but not overridden.

It is a good idea to always define a no-argument constructor

[public] interface AnInterface
  [extends SuperInterfaces, AnotherSuperInterface] {
  ...
  aMethod(params); // no body for methods, just ';'
}
public class RealClass
  implements AnInterface, AnotherInterface {
  ...
}

An interface is an abstract class where no methods have bodies and where there are no member variables (just constants that are by definition public static final). Methods are by definition public and abstract.

A class can inherit several interfaces (but only one class).

Unrelated classes can inherit the same interface.

The interface can be used as a type (for parameters).

Subclassing

Note cast "(Object)whateverObject"

Casting "up" is possible by simple assignment

Casting "down" is allowed by compiler if the new cast is a subclass
A run-time error occurs if the runtime type is not the subclass.

Casting "across" is not possible

Handler method must be exactly as shown. The class must be an implementation of ActionListener. It can also extend ActionListener.

Category is "Action"
Interface name is "ActionListener"
Method is "actionPerformed(ActionEvent)"

Use action category for the events on the menu items. Action events on menus are possible but unusual.

Can only add a menubar to a frame

g.drawString("...", x, y)

Draw the display. Called to handle exposure. Eventually, use the clip rectangle.

Exposure causes paint() to be called;
repaint() causes update() to be called, which should call paint()

Minimal example v.1.3

Swing components often use AWT :
import java.awt.*;
import java.awt.event.*;

JFrame

Single main window

JDialog

Secondary windows

JApplet

Applet display area

Button

This is an anonymous event handler

import java.io.*;

File aFile = new File ( ["path/",] "abcd");
File aDir = new File ("dir"); File aFile = new File ( aDir, "abcd");

Class File (or class FileDescriptor)

File streams: FileReader, FileWriter, FileInputStream, FileOutputStream

For random access files, see [1] page 12-16

The file can be a directory too; see listing with listFiles()

File aFile = new File ( ["path/",] "abcd");
try (FileInputStream s = new FileInputStream(aFile)) {
  .. // read file
} catch (IOException e) {
  System.out.println("Cannot read file");
}

try-with-resources statement ensures that the file is closed even in the case of an error

import java.net.*;

import java.net.*;
import java.io.* ;

import java.text.DateFormat;
import java.util.Date;

Date dtCurrent = new Date(); // defaulted to now

System.out.println(DateFormat.getDateInstance().format(dtCurrent));
System.out.println(DateFormat.getTimeInstance().format(dtCurrent));
System.out.println(DateFormat.getDateTimeInstance().format(dtCurrent));
System.out.println(DateFormat.getDateInstance(DateFormat.SHORT).format(dtCurrent));

// Get date format once and use several times:
DateFormat df = DateFormat.getDateInstance([DateFormat.LONG, Locale.FRANCE]);
myDate = df.parse(myString);
Also for time:
DateFormat df = DateFormat.getTimeInstance ([DateFormat.LONG, Locale.FRANCE]);


getString can be used with all data types

getByte, getShort, getInt, getLong
getFloat, getDouble, getBigDecimal
getBoolean, getString, getBytes, getObject
getDate, getTime, getTimeStamp
getAsciiStream, getUnicodeStream, getBinaryStream

javac
-classpath --> gives location of classes
-d directory --> put classes in directory
-g --> enable debugging
-verbose --> more output
filename.java

java [options] class_name args

java
-debug
-cs, -checksource --> check the timestamp of .java and compiles if necessary
-classpath path --> tell where classes are
-v, -verbose -->

<APPLET CODE=x.class >
<PARAM NAME="p1" VALUE="FirstParameter">
<PARAM NAME="p2" VALUE="SecondParameter">
</APPLET>

public void init() {
  aString = getParameter ( "p1" );
  anotherString = getParameter ( "p2" );
}

Passing parameters with an applet

Null if empty.

Not case sensitive.