Algorithm Programming 189-210

Bar-Ilan University

תשס"ח 2007-2008

by Moshe Fresko

Java Language Specifications

Controlling Program Flow Operators

Addition(+), subtraction and unary minus(-), multiplication(*), division(/), assignment(=) etc.

Produces a Value Side Effect Operators work only with primitives, except

=,==,!= for objects and +,+= for String Operator Precedence Assignment =

Primitive Data TypesType Size Min Max Wrapper Defautboolean - - - Boolean falsechar 16-bit Uni 0 Uni 216-1 Character ‘\u0000’byte 8-bit -128 +127 Byte (byte)0short 16-bit -215 +215-1 Short (short)0int 32-bit -231 +231-1 Integer 0long 64-bit -263 +263-1 Long 0Lfloat 32-bit Float 0.0fdouble 64-bit Double 0.0dvoid - Void

Assignment Operator (=) lvalue=rvalue rvalue is constant, variable, or expression lvalue is a physical space to store the value Primitive assignment Object assignment

class Number { int i; }public class Assignment { public static void main(String[] args) { Number n1 = new Number(); Number n2 = new Number(); n1.i = 9; n2.i = 47; System.out.println("1: n1.i: " + n1.i + ", n2.i: " + n2.i); n1 = n2; System.out.println("2: n1.i: " + n1.i + ", n2.i: " + n2.i); n1.i = 27; System.out.println("3: n1.i: " + n1.i + ", n2.i: " + n2.i); }}

Function Calls Aliasing can occur in Function Callclass Letter { char c; }public class PassObject { static void f(Letter y) { y.c = 'z'; } public static void main(String[] args) { Letter x = new Letter(); x.c = 'a'; System.out.println("1: x.c: " + x.c); f(x); System.out.println("2: x.c: " + x.c); }}

Primitive types pass as copy by value Values are returned as return-by-value

Mathematical Operatorsint i, j, k; float f, g, h;... ...i = j + k; f = g + h;i = j - k; f = g - h;i = k / j; f = g / h;i = k * j; f = g * h;i = k % j; i += j; f += g;i -= j; f -= g;i /= j; f /= g;i *= j; f *= g;i %= j;i = -j; f = -g;i = +j; f = +g;i++; ++i;i--; --i;

Relational Operators Have only boolean result Works on built-in data types <, >, <=, >=, ==, != == and != also work with objects (reference check)

public class Equivalence { public static void main(String[] args) { Integer n1 = new Integer(15); Integer n2 = new Integer(15); System.out.println(n1 == n2); System.out.println(n1 != n2); }}

equals ( ) : for comparing object contents

Logical Operators AND (&&), OR (||) and NOT (!) Short circuited

public class ShortCircuit { static boolean test1(int val) { System.out.println("test1(" + val + ")"); return val < 1; } static boolean test2(int val) { System.out.println("test2(" + val + ")"); return val < 2; } static boolean test3(int val) { System.out.println("test3(" + val + ")"); return val < 3; } public static void main(String[] args) { if(test1(0) && test2(2) && test3(2)) System.out.println("expression is true"); else System.out.println("expression is false"); }}

Bitwise and Shift Operators Bitwise operators

AND operator (&) OR operator (|) XOR operator (^) Bitwise NOT operator (~) is unary operator &=, |=, ^=

Shift operators << Left Shift >> Right Shift >>> Unsigned Right Shift with Zero Extension char, byte, or short will be promoted to int. int will use 5 low-order bits of rhs long will use 6 low-order bits of rhs <<=, >>=, >>>=

Operators Ternary if-else operator

boolean-exp ? value0 : value1 static int ternary(int i) { return i < 10 ? i * 100 : i * 10; }

The comma operatorOnly in for loops

String operator +int x = 0, y = 1, z = 2; String sString = "x, y, z ";System.out.println(sString + x + y + z); System.out.println(x + sString);

Operators Common pitfalls

while(x = y) { ... } instead of x==yCompiler error unless x and y are booleanif (x&y) { … } instead of x&&yCompiler catches this error

Castingint i = 200; long l = (long)i;

// superfluous cast, is not necessary, but clearer codechar c = (char) i ;

// necessary, otherwise does not compile Object casts

class B extends A { }a = b ; // okb = a ; // compiler error : incompatible typesb = (B) a ; // compiler ok, but run-time check (can throw ClassCastException)

Literalschar c = 0xffff; // max char hex value byte b = 0x7f; // max byte hex value short s = 0x7fff; // max short hex value int i1 = 0x2f; // Hexadecimal (lowercase) int i2 = 0X2F; // Hexadecimal (uppercase) int i3 = 0177; // Octal (leading zero) // Hex and Oct also work with long. long n1 = 200L; // long suffix long n2 = 200l; // long suffix (but can be confusing) long n3 = 200; float f1 = 1; float f2 = 1F; // float suffix float f3 = 1f; // float suffix float f4 = 1e-45f; // 10 to the power float f5 = 1e+9f; // float suffix double d1 = 1d; // double suffix double d2 = 1D; // double suffix double d3 = 47e47d; // 10 to the power

Precedence Unary +, -, ++, -- Arithmetic & Shift +, -, *, /, %, <<, >>,

>>> Relational <, >, ==, >=, <=, != Logical & Bitwise &&, ||, &, |, ^ Conditional A > B ? X : Y Assignment =, *=, +=, etc.

Execution Control if (Boolean-expression)

statement if (Boolean-expression)

statement else

statement while (Boolean-expression)

statement do

statement while(Boolean-expression);

for(initialization; Boolean-expression; step) statement

Execution Control return, continue, break, continue label, break label

label1: outer-iteration {

inner-iteration { //... break; //... continue; //... continue label1; //... break label1;

} }

switch, case, breakswitch(integral-selector) {

case integral-value1 : statement; break; case integral-value2 : statement; break; …default: statement;

}

Constructor Default Constructor

class Rock { Rock() { System.out.println("Creating Rock"); }

} public class SimpleConstructor {

public static void main(String[] args) {for(int i = 0; i < 10; i++)

new Rock(); }

}

Constructors with Parametersclass Rock {

Rock(int i) { System.out.println("Creating Rock"+i); } } public class SimpleConstructor {

public static void main(String[] args) {for(int i = 0; i < 10; i++)

new Rock(i); }

}

Method Overloadingclass Tree {

int height; Tree() {

System.out.println("Planting a seedling"); height = 0;

} Tree(int i) {

System.out.println("Creating new Tree " + i + " feet tall"); height = i;

} void info() {

System.out.println("Tree is " + height + " feet tall"); } void info(String s) {

System.out.println(s + ": Tree is " + height + " feet tall"); }

}

Method Overloading Java distinguishes between overloaded methods according to

parameters.void p(string s, int i) { … }void p(int i, string s) { … }

Overloading with primitivesvoid p(byte b) { … }void p(int i) { … }… p(100) ; // p(int) is called

No overloading on return values Default constructor

class Bird { int i; }… new Bird() ; // ok class Hat { int i ; Hat(int x) { i=x; } }… new Hat() ; // compiler error

this this keyword

this.func() return this

Calling constructors from constructorsclass Flower {

Flower(int i) { … }Flower(string s) { … }Flower(int i,string s) {

this(i) ; // The first line, and only once…

}}

this cannot be used in Static methods

Clean up GC : Garbage Collection No destructor, only finalize() method neither GC nor finalize() is guaranteed System.gc( ) can be called for GC

Member Initialization Primitive Data types are initialized automatically Object Reference is initialized to null Specifying initialization (either in Class definition or in

Constructor)class X {

boolean b = true; char c = 'x'; Depth d = new Depth();int i = f(); int j = g(k) ; // Compiler Errorint k ; { k = 30 ; … }

Order of initialization, like the order of members in the class definition

Static Initialization Can be initialized in either way

static int i ; static int j = 3 ; static int k ;

static { k = 5 ; … } Static members are initialized when

A new object created Any static member is accessed

Array Initialization int a[] ; int[] a ; int[] a = { 1, 2, 3, 4, 5 }; int[] a = new int[5] ; X[] a = { new X(1), new X(2), new X(5) }

a.length

Multi-dimensional Arrays int[][] a ; int[][] a = { { 1, 2, 3, }, { 4, 5, 6, } }; int[][][] a = new int[2][2][4]; int[][][] a = new int[3][][];

a[2] = new int[5][]; a[2][3] = new int[6];

X[][] x = { { new X(1), new X(2) } , { new X(3) } } X[][] x = new X[3][] ;

x[1] = new X[4] ;x[1][2] = new X(54) ;

Array Parameters and Return Values void f(int[] array) { … }

int[] n = new int[100] ;obj.f(n) ;

Arrays are passed as object reference int[] initNewArray(final int sz, final int val)

{ int[] arr = new int[sz] ; … ; return arr ; }int[] a = initNewArray(10,4) ;

java.util.Arrays. binary_search(…,…) equals(…,…) fill(…,…,…,…) sort(...)

Arrays Index from 0 Arrays are created with new Arrays are treated as regular objects Boundary errors are found at runtime Don’t use regular arrays for dynamic arrays, it

can waste memory and time, and can create non-readable code