Java Quick Reference


Syntax for a class (including constructors, methods, and fields)

Class Syntax

 * Description of the class
accessSpecifier class ClassName

    // Data Members (fields)

    accessSpecifier fieldType fieldName; // description of field

    // Constructors

     * Describe what constructor does
     * @param p1 describe the first parameter
     * @param p2 describe the second parameter
    accessSpecifier ClassName(paramType paramName, paramType paramName)
        // constructor body
    // Methods

     * Describe purpose and use of the method.
     * @param p1 describe the first parameter
     * @param p2 describe the second parameter
     * @return describe the value returned
    accessSpecifier returnType methodName(paramType paramName, paramType paramName)
        // method body



 * A Human has a name and an age.  A human's name can be changed at any time.
 * A human's age only changes when the human has a birthday.
public class Human {

    private String name;  // the human's name
    private int age;      // the human's age
     * Creates a human with the given name.  The human starts out at age 0.
     * @param initName the name to give the human
    public Human(String initName) {
        name = initName;
        age = 0;
     * Returns the name of this human.
     * @return the name of the human
    public String getName() {
        return name;
     * Returns the age of this human.
     * @return the age of the human
    public int getAge() {
        return age;
     * Changes the name of this human to the new name given.
     * @param newName the new name for the human
    public void setName(String newName) {
        name = newName;
     * Causes the human to have a birthday (i.e., adds a year to the age).
    public void haveBirthday() {
        age = age + 1;

Primitive and reference types

Primitive vs. Reference Data Types


Comparisons (e.g., ==)

Passing Parameters

Returning Values

Java operators and operator precedence

Numeric operators

arithmetic operators

%modulus (remainder)

Note: applying an operator to two integer operands results in an integer result. For example, the result of 13 / 5 (an int divided by an int) is 3.

unary operators

+unary plus      ++increment
-unary minus      --decrement

compound assignment operators

+= -= *= /= %=
For each compound assignment operator op=,
x op= y;   is the same as   x = x op y;

Relational (comparison) operators

==equal to      !=not equal to
>greater than      >=greater than or equal to
<less than      <=less than or equal to

Logical (boolean) operators

!NOT (unary)

See Java operator precedence for information about Java's order of operations.

Syntax for decision statements


if ( boolean expression )
	if block
	else block


switch ( arithmetic expression ) {
	case label 1 : case body 1
	case label 2 : case body 2
	case label n : case body n

Syntax for loops (repetition statements)


while ( boolean expression ) 


do {
} while ( boolean expression );


for ( initialization ; boolean expression ; increment )

Syntax for interfaces (defining and implementing)

Defining an interface

Java Syntax

public interface InterfaceName {
	method prototypes


public interface Ownable {
    Owner owner();
    boolean updateOwner(Owner newOwner);

Implementing an interface

Java Syntax

public class ClassName implements InterfaceName1, InterfaceName2, ... {
	data members


public class Car implements Ownable {

    // data members
    private Owner myOwner;
    // constructors
    // other Car methods
    public Owner owner() {
    	return myOwner; // method implementation
    public void updateOwner(Owner newOwner) {
        myOwner = newOwner;
        return true;


Throwing an Exception - where the error is detected

throw exceptionObject;

Example: throw new IllegalArgumentException();

Handling an Exception

using try-catch

try {
    code that might raise an exception 
} catch (ExceptionType1 identifier1) {
    code to handle exception type 1    
} catch (ExceptionType2 identifier2) {
    code to handle exception type 2   
} ...
finally {  // note: the finally clause is optional
    code executed no matter what happens in try block   

using a throws clause

... methodName(parameter list) throws ExceptionType { ...

... methodName(parameter list) throws ExceptionType1, ExceptionType2, ... { ...

Example: public static void main(String [] args) throws IOException { ...

Defining an Exception

Define a new class that is a subclass of Exception (either directly or through the inheritance hierarchy).


public class EmptyBagException extends Exception {

    public EmptyBagException() {
    public EmptyBagException(String msg) {

File and console input and output

See also:

Console I/O

For console input, use a Scanner object

For console output, use System.out

File I/O

For file input, use a Scanner object

For file output, use a PrintStream object