Java Basics

 Variable scope
o Class scope
 Non-static variables defined in a class are accessible within the class
methods without using the class or instance name or “this”.
 Static variables
o Method scope
 Variables declared in the method and arguments of the method are only
available within the method.
 If an argument of the method has the same name as a class variable, the
method’s version will be used rather than the class version.
 If a variable with the same name as a class variable is declared in the
method, the method’s version will be used rather than the class version.
o Block scope
 A variable declared in a block of code will only be available in that block
of code.
 Variables may be declared anywhere in a block or method but will only be
valid after the declaration.
 Variables declared in a block will be accessible inside a new nested scope
under the scope they were declared in.
 You cannot declare a variable in an inner block scope with the same name
as a variable in the outer block scope.
o Variables are created only when their scope is entered.
o Variables are destroyed when their scope is left.
 Class structure
o Static members belong to class, not instance
 Can be used to keep track of how many instances of a class have been
created
o Constants declared with “static final” modifiers
 Cannot be reassigned, compile-time error will occur
o Access level modifiers
 public
 world accessible
 protected
 subclass and package accessible
 package-private
 default for no modifier
 package accessible
 private
 only accessible within class
 Executable applications
o A Java class is made executable from the command line by creating a main
method using the declaration: public static void main(String args[])
 A main method that returns a value will compile but will produce an error
when executed
 o First command line argument is args[0].
 Import Java packages
o Import package member using import package.member
o Import complete package using the wildcard character
o Java compiler automatically imports the java.lang package and the current
package
o If more than one package you have imported contains the same member name,
you must refer to it using the member’s fully qualified name.

Java Data Types

 Declare and initialise variables
o Declared using syntax: type identifier
o Multiple variable of the same type may be declared in the same statement,
separating the identifiers with commas.
o Variables may be declared and initialised on the same line.
o Multiple variables of the same type may be declared and initialised on the same
line, by putting a comma after the value of each variable and then supplying the
next identifier.
o Variables may be dynamically initialised with any valid expression at time of
declaration.
 Object reference variables
o When instantiating an instance of a class, we declare a reference variable and then
allocate a new instance of the class to the reference
o Class name and arguments specify the constructor to be used
 Primitive variables
o 8 Primitive types:
 byte – 8 bits signed
 short – 16 bits signed
 int – 32 bits signed
 long – 64 bits signed
 float – 32 bits single precision
 double – 64 bits double precision
 char – 16 bits unicode
 boolean – true or false – not 0 or 1
 Integer literals:
o Whole number value is an integer literal, assumed to be decimal
o Octal values denoted by a leading 0
o Hexadecimal values denoted by a leading 0x
o Binary values denoted by leading 0b – beginning with JDK 7
o No error produced when assigning an integer literal that is within the range of the
type
o To specify a long literal append an L(upper-case or lower-case) to the end of the
literal
o Underscores may be embedded in integer literals
 Floating-point literals:
 o Default is double precision
o To specify float, append F to the literal
o To specify double, append D to the literal
o Scientific notation uses a floating point number plus suffix indicated by E
followed by a decimal number with is the power of 10 to which the number is
multiplied.
o Hexadecimal floating point literals may be used with prefix 0x, but scientific
notation then uses P rather than E.
o Underscores may be embedded in floating-point literals
 Character literals:
o Enclosed in single quotes(‘)
 Read and write object fields
o Inside the class just use the field name.
o Outside the class use the instance name, dot operator and field name.
 Object lifecycle
o Variables are created when their scope is entered and destroyed when their scope
is exited.
o Objects will be eligible for garbage collection when there is no reference pointing
to them.
 Call object methods
o Within the class just use the method name.
o Outside the class use the instance name, dot operator, method name and required
arguments.
 StringBuilder class see tutorial
o Identical to StringBuffer, is faster, but is not synchronized so is not thread-safe
o Represents growable and modifiable character sequences
o Provides utility functions for characters or substrings to be inserted into or
appended onto a string.
o Use append() to add more characters to the string
o Use charAt() to get the character at a particular index –
throws IndexOutOfBounds exception if index is invalid.
o Use length() to get length of string
o Use substring(int index) to return all characters from index to end of string or
substring(int start, int end) to return characters between start and end inclusive.
 Strings
o Strings are immutable – cannot be changed once created
o A string object is automatically created for every string literal
o The + operator may be used to concatenate strings
o To compare two strings use the equals() or equalsIgnoreCase() methods of the
String class
o Use the compareTo() or compareToIgnoreCase() method to compare whether a
string comes before or after another string in dictionary order.
o Use length() to get length of string
o String methods that return a new String object may be used with the assignment
operator to replace the an existing String object.
 o String methods that “modify the string” don’t actually modify the string, but
return a modified copy of the String.

Operators and Decision Structures

 Operators
o Arithmetic Operators: + – * / % ++ += -= *= /= %= —
o Bitwise Operators: ~ & | ^ >> >>> << &= |= ^= >>= >>>= <<=
o Relational Operators: == != > < >= <=
o Boolean Logical Operators: & | ^ || && ! &= |= ^= == != ?:
o Assignment Operator: =
o Ternary Operator: ?
o Type Comparison Operator: instanceof
o Watch for mixed types of operators used in unusual ways in statements.
o Recognising the type of operator is important
o Be sure to know your operator precedence order, particularly postfix and prefix
increments and decrements and arithmetic operators.
 Parentheses
o Raises the precedence of operations inside them
o May be used to alter the precedence or clarify the meaning of the expression
 Object and string equality
o == determines if the variable references refer to the same object
o .equals compares the contents of the two objects
 If/else statements
o May contain just one statement or a block
o May be nested, but the if-else-if ladder structure is preferred
 Switch statements
o Statements in a switch case must be labeled with one or more case or default
labels.
o break statement branches execution to first statement after switch block
o break may be omitted from a case in order to have execution fall through to the
next case’s statements
o Prior to JDK 7 only byte, short, int or char expressions may be used in a switch.
o In JDK 7 and above String may be used.
o switch is more efficient than if’s, but may only test equality of contents of
expression

Arrays
 One-dimensional arrays
o Braces may follow the type or the variable name.
o Array memory must be allocated using the new keyword and size must be
specified in braces after the type
 Multi-dimensional arrays
o Braces may follow the type or the variable name.
 o When specifying the size of a multi-dimensional array only the first dimension
size needs to be specified. The second dimension size may be allocated manually
for each index of the first dimension.
o It is possible to create uneven or irregular multi-dimensional arrays – a triangular
multi-dimensional array even!
 java.util.Arrays has utility static methods for manipulating arrays
 Arrays are objects and all methods of class Object may be invoked on an array.
 ArrayList
o Supports dynamic arrays which can grow when needed.
o Automatically enlarged when needed.
o May be shrunk when objects are removed.
o Declared in form: ArrayList<type> var = new ArrayList<type>()
o Contents may be returned using default toString() method.
o Can be converted to an array using toArray() method. Needed for use with an
enhanced-for loop.
o Use get(index) method to access a value.
o Use add(element) to append to list
o Use add(index, element) to insert in a list – index must be less than the size() of
the ArrayList.
o Use remove(index) to remove from ArrayList.
o Use remove(object) to remove the first occurrence of object from the ArrayList.
o Use clear() to remove all elements from the arraylist.

Loops
 While loops
o Only run if controlling expression is true
o May not run at all if expression is false when execution reaches the loop
o Does not require a body if the controlling expression can handle all required
functionality
 For loops
o General form: for(initialisation; condition; iteration)
o Commas allow multiple initialisation and iteration statements
o Initialisation and/or iteration statements may be absent
o All three parts may be empty for an infinite loop
 Enhanced for loops
o General form: for(type variable : collection)
o Iterates through a collection and places the current value in the variable
o May be used for multi-dimensional arrays using nesting
 Do/while loops
o Always runs once, subsequent runs will occur if the controlling expression is true
at the end of the first iteration.
o Decrement/Increment may be included in the controlling expression as a pre-fix
decrement/increment preceding the comparison
 Break and continue
 o break terminates the loop and execution continues with the first statement after
the loop
o continue terminates the current loop iteration and execution continues with the
next loop iteration
o break label breaks out of the named block of code
o continue label ends the current iteration of the block label and triggers the next
iteration to begin
o break may only be used within a switch block’s case or default labels or in a loop.
o continue may only be used in a loop.

Methods and Encapsulation

 Method arguments and return values
o A method may accept values into variables which are known as parameters
o A method that accepts parameters is passed arguments(variables or literals) when
it is called
o Void methods do not return values or include a return statement.
o Non-void methods must return a value via the return statement.
o The last parameter of a method may be a varargs parameter which may accept an
arbitary number of values. The syntax is: type… array_name
 Static keyword
o Static variables are essentially global variables
o Static methods can only directly call other static methods
o Static methods can only directly access static data
o Static methods cannot use this or super – it will cause a compilation error
o Static members can be accessed before an instance of its class is created and
without reference to an object.
o Inside their class static members can be used without specifying the name of the
class.
o Outside their class static members can be used by specifying the class name
followed by the dot operator and member name.
 Overloaded methods
o Overloaded method use the number and types of arguments to determine which
version of the overloaded method to call.
o Return type are not used to determine which overloaded method to call.
 Default and user-defined constructors
o If no user-defined constructors are provided for a class, the compiler will supply a
default no argument constructor
 Create and overload constructors
o If a class will be inherited, a no argument constructor should be supplied.
 Access modifiers
o public
 Can be accessed by any other code
o private
 Can only be accessed by other methods in its class
o protected
  Applies only with inheritance
o default
 Also known as package-private
 Accessible from all classes within its package
 Encapsulation
o Declare variables of a class private
o Provide public setter and getter methods
 Call by reference vs call by value
o Primitives types are passed by value – the method has a copy of the primitive and
can’t change the original variable
o Object types are passed by reference – the method can change the original object

Inheritance
 Implementing inheritance
o Java implements single inheritance
o On instantiation of a subclass, the no-arg constructor of the superclass will be
executed prior to the subclass constructor running
o Subclass cannot access those members of a superclass that have been declared
private
o Declaring a method as final means it cannot be overriden by a subclass – a
compile-time error will occur
o Declaring a class as final means it cannot be inherited.
 A class cannot be abstract and final
 Polymorphism
o Subclasses of a class can implement their own unique behaviour but
share common functionality with the superclass
o Achieved by overriding superclass methods to provide unique behaviour in the
subclass, while also adding additional unique methods specific to the subclass
 Reference type vs object type
o A reference variable may be declared to be of a type that is a superclass of the
actual object type
o Reference type determines which members of the object are accessible
o Only those members declared in the reference type will be accessible, so some
members of actual object type may not be accessible
 Casting
o Where a superclass has been used as reference type, the object may be cast to the
actual type to access members that are not part of the reference type
 Super
o May be used to call the constructor of a superclass – the signature will determine
which constructor
o May be used to refer to a method or instance variable in the superclass
 This
o this is a reference to the current object
o this() can be used to invoke an overloaded constructor
o this may be used to refer to a redefined instance member variable from a method.
  Interfaces
o An interface is a a reference type, like a class, that can only contain constants,
method signatures, default methods, static methods and nested types.
o Cannot be initialised
o Are designed to be implemented by classes or extended by other interfaces
o A class based on the interface uses the implements keyword to declare this.
 Abstract classes and interfaces
o Abstract classes cannot be initialised
o Abstract classes are able to be subclassed, with subclasses inheriting the methods
provide by the abstract class
o An abstract class may implement an interface

Exceptions
 Checked exceptions
 All exceptions and errors are subclasses of Throwable.
o Throwable defines a method getMessage() which returns a string with details
of the exception or error
o Throwable defines a method printStackTrace() which prints a stack trace of the
exception or error to the console.
 Exceptions other than subclasses of RuntimeException, Error
o RuntimeExceptions
 Subclasses of RuntimeException are unchecked by the compiler
 Common RuntimeException subclasses:
 ArithmeticException
 IndexOutOfBoundsException
 IllegalArgumentException
 NoSuchElementException
 NullPointerException
o Errors
 Subclasses of Error are unchecked by the compiler
 Not expected to be caught under normal circumstances by your program.
 Indicates errors with the run-time environment
 Created in response to catastrophic failures that cannot be handled by your
program
 Common Error subclasses:
 IOError
o Common checked exceptions:
 IOException
 Try-catch blocks
o Try
 Encloses a block of code that might throw an exception
o Catch
 Catch blocks must catch exception subclasses before any of their
superclasses.
  Subclass catch blocks would not be reached if superclass catch
blocks came first. Unreachable code in Java causes a compile
error.
 Multiple exceptions can be handled by the same catch block by using the
pipe operator |
 Execution never returns to the try block
o Finally
 Code in the finally block is always executed after the try block completes
 Uses of exceptions
o Definition: An exception is an event, which occurs during the execution of a
program, that disrupts the normal flow of the program’s instructions.
o When an exception is thrown the runtime system searches down the call stack
looking for an appropriate handler.
 Using a method that throws an exception
o Must catch or re-throw the exception
o Common exception classes and categories
o A method that can cause an exception it doesn’t handle must declare it in the
method definition using the throws clause.