Definition:

Standard Out  is the output that is normally directed to the terminal console.

Standard In  is the input that is normally read from the terminal keyboard.

Standard Err  is the error message output that is normally sent to the terminal console.

More on Strings
String is a predefined JAVA class in the standard JAVA library.

Substrings are subsets of some defined String.  Substrings themselves are Strings.

Strings can be concatenated by joining them with a "+" sign.

Testing strings for equality can be done using String's "equals" or "equalsIgnoreCase" methods.

The "trim" method returns a new string without the leading and trailing spaces.

Data Input
Console class, used by most pre- JDK 5.0 programmers, will read input from the terminal console window. one character at a time to form a string.

Scanner class, new with JDK 5.0, will read input from the terminal console window.

JOptionPane class, using the showInputDialog method, will put up an input window to enter the input you wish read along with a prompt.

Data Output
System.out.println which is the "println" method of the "PrintStream" class called by the "out" field property of the static "System" class is the standard way to write data to the terminal console followed by carriage return/linefeed character to cause a blank line following the outputted data.

System.out.printf which is the "printf" method of the "PrintStream" class called by the "out" field property of the static "System" class is the new JDK 5.0 opting to put data to the terminal console with formatting.

Definition:

Exceptions  are events that occur during the execution of a program and may disrupt the normal flow of control.  A program that does not provide logic for handling exceptions may abnormally terminate, causing problems for the user.  JAVA provides programmers with the capability to handle runtime errors.  This is referred to as exception handling. 

Possible errors can be caught by using the try-catch[-finally] block construct.  This allows the exceptions to be handled programmatically, prevent "ugly" messages to the user and permit execution to continue.  If an exception occurs within the try clause then the remainder of the lines in the try clause are skipped and the control is then transferred to the catch clause.  After the exception is caught and processed, control is transferred to the finally clause, if there is one, or to the next statement after the try-catch block.

If you as a programmer do not catch the exception, the JVM will and put out an ugly message(s) for your users, then terminate execution.

Prototype:    try
                    {
                    some set of statements, on of which you expect may throw an exception;
                    }  // end of try clause
                    catch
                        {
                       statements that handle the exception event;
                        }  // end of catch clause
                    finally
                        {
                        some set of statements that will always execute, exception or no;
                        } // end of finally clause

                    The next statement following try-catch-[finally] block

Example:    String s = null;
                  try
                    {
                    System.out.println("The contents of string s is " + s.toString() );
                    }
                    catch (NullPointerException exc)
                       {
                        System.out.println("Error, string s is NULL " + exc.getMessage());
                        }
                    finally
                        {
                        s = "ABC";
                        }
                    System.out.println("The contents of string s is " + s);      

JAVA has 3 classes of exceptions: 
system errors are thrown by the JVM and describe internal system errors

exceptions describes errors caused by your program and external circumstances.  These should be caught and handled by your program.

runtime exceptions are those that describe programming errors, such as bad casting, accessing an out of bounds array and numeric errors.  They are generally thrown by the JVM.

If an exception occurs that is caught by your program's catch statement, then the particular exception class is instantiated and can be referenced by the variable name you assign to the exception.  Using this instance variable you can call on its method "getMessage()" to obtain information regarding the cause of the exception.

Example:    System.out.println("An error occurred, information received is: " + exc.getMessage() );

Flow Control

Program flow control concerns itself with the order in which statments are executed in a program.  Most programming does not execute its statements in sequence.  Often situations occur in which you must provide alternate instruction paths.

If-then-Else Statement
This statement allows you to take actions when a condition is true and alternative actions when the condition is false.

Prototype:    if (boolean_expression)
                        {
                        statements for when condition is true;
                         }
                    else
                        {
                        statements for when condition is not true;
                        } 

Example:      boolean starsAreOut = false;
                    if (starsAreOut)
                        {
                        System.out.println("It is daytime.");
                         }
                    else
                        {
                        System.out.println("It is night.");
                        }

Nested If 
The statement in an if can be any legal JAVA statements including another if or if...else.  The inner if statements are said to be "nested".  There is no limit to the depth of nesting,  but after a few it does make it difficult to match up your IF and ELSE statements.

Definition:

The SWITCH

SWITCH  statements are employed when nested IF-ELSE statements would make a program difficult to read and interpret by the human programmer.  The SWITCH statment will handle multiple conditions efficiently and may make it easier to program and debug.

Prototype:  switch (expression) {
                    case value1:    stmts;
                                  break;
                    case value2:    stmts;
                                    break;
                    case value3:    stmts;
                                    break;
                    case value N:    stmts;
                                    break;
                    default:    stmts;
                }

The "switch" statement will check all cases and execute beginning at the statement in the matched case.  It will execute or "fall-through" all remaining statements unless there occurs a "break;" statement. 

The switch "expression" must yield a value of char, byte, short or int type.  The "value" must have the same data type as that yielded by the switch "expression".

LOOP Statements

Loops are constructs that control repeated iterated executions of a block of statement code.  Each loop contains a loop continuation condition that controls the execution.  Prior to each iteration the loop continuation condition is re-evaluated.  If the condition is true, then the execution continues, if the condition is false then the loop terminates and passes control to the next statement outside of the loop.

There are three types of loop in JAVA:  while, do-while and for      

while loop

while (continuation_condition_is_true) 
{
    statements;
}

for loop

for (initial_value;  continuation_condition_is_true;  action_after_each_iteration) 
{
    statements;
}

Nested loops are loop constructs within loop constructs.  The nested loop appear to the outer loop as a statement to be executed independently. 

 Any loop can be terminated early by way of the break statement.  The break statement issued in an inner loop will cause execution to continue with the next statement in the set of statements being performed by the outer loop. 

Any iteration within a loop can be terminated early by way of the continue statement.  The continue statement will cause a pre-empting of any further statements in this iteration of the loop and continue the loop with the next iteration.

Nested for loop

for (initial_value_a;  continuation_condition_is_true;  action_after_each_iteration) 
{
    statements;
        for (initial_value_b;  continuation_condition_is_true;  action_after_each_iteration) 
         {
         statements;
         statements;
         break;  (or continue;)
         }
    statements;
}

Definition:

Calling a Method 

In creating a subroutine, you give a definition of what the routine is to do.  To employ the subroutine you have to call or invoke it by way of a method call.  The subroutine must reside in either this class or another class which your program has access to via packaging or import statment.  There are two ways to call a subroutine; the choice is based on whether the method returns a value or not.

If the method returns a value it is called a function.

Example:    int root = Math.sqrt(196);

If the method returns no value it is known as a void method or  a procedure.

Example:    System.out.println("Hello World"); 

Method Prototype Definition:
modifier  return_value  method_name(formal parameters)

Example:    public  int  mySubroutine(int arg1, int arg2, String arg3, double arg4)

Prototype for Invoking a method:
type result = method_name(formal parameters);

Example:    int rc = mySubroutine(arg1, arg2, arg3, arg4);

Transfer of Control
When one program calls a method, program control is transferred to the called method.  A called method returns control to the caller when its return statement is executed.

Passed Arguments
Each argument, if any, in the calling statement are matched positionally with arguments in the called method.  The corresponding arguments must match by type and order.  All arguments are passed by value, changes made to the variable in the called method do not affect the variable in the calling method.

Results
The result passed by the called method back to the calling method must be of the same type.  The result is placed as a variable or a literal in the return statment.

Method Overloading
If two or more methods have the same name but different parameter lists, the JAVA compiler determines which method is used based upon the "method signature".  This is called "overloading".

Scope of Variables
The scope of a variable is the part of the program where the variable can be referenced.  A variable defined inside a method is referred to as "local".  The scope of a local variable starts from its declaration and continues to the end of the code block that contains the variable.

A variable that is defined outside of all methods but within the class is called "global" to all in-class methods.  

Method Abstraction
Method Abstraction is a concept that is achieved by separating the use of a method from its implementation.  The user can call a method from some class without any knowledge of how it is implemented.   The details of the implementation are contained in the method and hidden from the client who invokes the method.  The user simply invokes the method passing the arguments required and expects a certain type of result to be returned.  This "black box" programming is known as encapsulation.  Of course, for encapsulated routines to be understood they must be well documented.

Definition:

An Array is a fixed-size sequential collection of elements of identical types.  In JAVA they are defined to be of some fixed immutable number of elements.  During allocation the array size must be given to specify the number of elements that can be stored in it.

Prototype for Declaring an array:
datatype[] ArrayReferenceName;

Example:    String[] myArray;

Prototype for Creating an array:
ArrayReferenceName = new datatype[number_of_elements];

Example:    myArray = new String[100];

Prototype for Declaring and Creating an array in one step:
datatype[] ArrayReferenceName = new datatype[number_of_elements];

Example:    String[] myArray = new String[100];

FYI: While the array variable appears to hold an array, it actually contains just a reference to that array.  The array variable and the array are different.

Initial Storage Contents

When an array is created its elements are initialized with the value of ZERO if the data type is defined as numeric.

If the array data type is defined as String or char then it is filled with unicode '\u0000' (null characters).

If the array data type is defined as boolean then each element is set "false".

Relative Addressing

The size of the array can be queried by using the Array Reference Variable Length.

ie.    int myTableSize = myArray.length

The array elements are accessed through an index.  The index variable must be an integer.

The first element of an array is Element ZERO.

ie.    myArray[0]

The last element of an array is one less than the Array Reference Variable Length,

ie.    myArray[myArray.length - 1]

Accessing an array out-of-bounds is a common programming error.  It will throw a runtime ArrayIndexOutOfBoundsException.  To avoid this error, make sure that you do not use an index beyond  arrayRefVar.length - 1.

Copying Arrays

To copy one array to another you can:
1) Use a loop to copy individual elements.
2) Use the static arraycopy method in the System class.

Note that the statement  arrayList1 = arrayList2 may appear to copy the array but it is simply creating another reference pointer to the same array.

Passing Arrays to Methods

JAVA uses "pass by value" to pass arguments to a method if the arguments are the variables of primitive data types.  For an argument that is of an array type, the value of the argument contains a reference to an array; this reference is passed to the method.

ie.    int[] x = new int[100];
        rc = someRoutine(x);

        public int someRoutine(int[] y)
        {...
        return 0;
        }

Returning an Array from a Method

A method may also return an array.  Again it returns a reference pointer to the caller.

.ie.    int[] x = new int[100];
        rc = someRoutine(x);

        public int[] someRoutine(int[] y)
        {
        int[] result = new int[10];
        for (int i = 0; i < 10; i++)
            {
            result[i] = i*2;
            }
       return result;
        } 

Definition:

An Multi-Dimensional Array is a fixed-size sequential collection of elements of identical types, like a single dimensional array, but is is used to represent n-dimensional data structures.  During allocation the array size in all dimensions must be given to specify the number and type of elements that can be stored in it.

Arrays of 2 dimensions are called tables or matrices.  Tables are usually identified with rows and columns.

Prototype for Declaring a 2-dimensional array, a.k.a table:
datatype[] ArrayReferenceName;

Example:    String[][] myArray;

Prototype for Creating a 2-dimensional array, a.k.a table:
ArrayReferenceName = new datatype[number_of_row_elements][number_of_column_elements];

Example:    myArray = new String[100][50];

Prototype for Declaring and Creating a matrix in one step:
datatype[][] ArrayReferenceName = new datatype[Y number_of_elements][X number_of_elements];

Example:    String[][] myArray = new String[100][200];

This creates a tables of strings with 100 rows and 200 columns.

Relative Addressing
A multi-dimensional array is actually an array in which each element is another array. 

The elements  x[0], x[1], x[2], ..., x[n-1] are arrays in themselves. 

The size of the array in the first dimension can be queried by using the Array Reference Variable Length.

ie.    int myTableSize = myArray.length

The sizes of the arrays in the second dimension can be queried by using the Array Reference Variable Length of each element from the first dimension.

ie.    int myTableSize = myArray[0].length

        int myTableSize = myArray[1].length

        int myTableSize = myArray[myArray.length-1].length

The array elements are accessed through an multiple indices.  Each index variable must be an integer.

The first element of a table can be thought of as Row Zero, Column Zero .

ie.    myArray[0][0]

The last element of a table is one less than the Array Reference Variable Length for both rows and columns.

ie.    myArray[n][m]    

ie.    myArray[myArray.length - 1] [myArray[myArray.length-1].length - 1]

Definition:

Inheritance is the object-oriented programming concept that allows you to derive new classes from existing ones.  In fact, every class in JAVA is inherited from an existing class, either explicitly or implicitly.  The parent of all JAVA classes is Object

If class PGM1 is derived from another class PGM2, then PGM1 is called a subclass (or child class) and PGM2 is called its superclass (or parent class).

A subclass inherits accessible variables and methods from its superclass.  

The subclass may extend the superclass by adding new variables and methods. 

Note that the subclass is NOT a subset of its superclass.  On the contrary since the subclass extends and is a specialization of the superclass; every instance of a subclass is an instance of its superclass. Therefore it is the superclass that is a subset of the subclass.  

The inheritance relationship enables a subclass to inherit features from its superclass with additional new features.

"this" and "super" keywords
The "this" keyword refers to the object or class in which you are in when using the keyword.
The "super" keyword refers to the superclass of the class in which you are in when using the keyword.

Calling Superclass Constructors
The syntax to call a superclass constructor is:     super();     or     super(parameters);

The statement super() must appear in the first line of the subclass constructor.  If not invoked explicitly then the compiler puts super() as the first statement in the constructor.

Calling Superclass Methods and Using Superclass Properties
The keyword super can also be used to reference a method or property that is accessible from the superclass.

            super.myVariable
            super.myMethod(parameters)

Overriding Methods
Sometimes it is necessary for the subclass to modify the implementation of a method defined in the superclass.  This is referred to as "method overriding"

Note: Static methods can be inherited but it cannot be overridden.

Polymorphism
Every instance of a subclass is an instance of its superclass.  Therefore, you can always pass an instance of a subclass to a prameter of its superclass type.  An object of a subclass can be used by any code designed to work with an object of its superclass.  This feature is known as polymorphism (Greek: meaning "many forms")

Polymorphism allows methods to be used generically for a wide range of object arguments.  If a methods parameter type is a superclass (ie. Object) you may pass an object to this method of any of the parameter's subclasses. 

Example:
public class PolymorphismDemo {
  public static void main(String[] args) {
    gprint(new GraduateStudent());
    gprint(new Student());
    gprint(new Person());
    gprint(new Object());
  }

  public static void gprint(Object x) {
    System.out.println(x.toString());
  }
}

class GraduateStudent extends Student {
    public GraduateStudent() {
        super();
    }
}

class Student extends Person {
    public Student() {
        super();
    }
  public String  toString() {
    return "Student";
    }
}

class Person extends Object {
  public Person() {
   }
  public String  toString() {
    return "Person";
  }
}

Protected Data and Methods
The modifiers private, protected and public are known as visibility or accessibility modifiers because they specify how class and class members are accessed.

A protected data field or method in a public class can be accessed by any class in the same package or its subclasses.

Use the private modifier to hide the members of the class completely so that they cannot be accessed directly from outside the class.

Use no modifiers to allow the members of the class to be accessed directly from any class within the same package but not from other packages.

Use the public modifier to enable the membrs of the class to be accessed by any class.

The private and protected modifiers can only be used for methods and variables.

The public and no modifier (default) can be used on members as well as the class itself.

Definition:

Class design should ensure that a superclass contains common features of its subclasses.  Sometimes a superclass is so abstract that it cannot have any specific instances nor define any concrete implementation details defining behaviour.  Such a class is referred to as an Abstract class.  

Prototype:
public  abstract class myAbstractClass {
    public abstract int mySubroutine();
    public abstract int yourSubroutine();
}

JAVA does not allow multiple inheritance.  Each JAVA class may inherit directly from at most one superclass.  This restriction is known as single inheritance.

An abstract class will define methods that cannot be implemented in the superclass because their implementation details are dependent on the specific type of object being defined by the subclass. These methods are referred to as abstract methods.

Abstract classes are like regular classes with variables and methods, but you cannot create instances of abstract classes via the "new" operator.  An abstract method is a method signature without implementation.   The abstract class can contain concrete methods as well as signature-only methods. The implementation is to be provided by the subclasses.

An Interface is a classlike construct that contains only constants and abstract methods.  An interface is similar to an abstract class, but an abstract class can contain variables and concrete methods as well as constants and abstract methods.  Each method of an Interface has only a signature without implementation.

Prototype:
modifier  interface myInterfaceName {
}

Interfaces are similar to abstract classes and you can use them more or less the same way.

A class may implement multiple Interfaces.

An Interface may extend (and therefore inherit) multiple super Interfaces.

Both Abstract classes and Interfaces are used to define generic classes and methods.