Lexical Tokens

• The smallest language elements are called lexical tokens and are the building

blocks for more complex constructs.

• Examples: Identifiers, numbers, operators, and special characters.

• Tokens are can be used to build high-level constructs like expressions,

statements, methods, and classes.

 Identifiers

• Identifiers are names given to program elements like classes, methods,

variables, labels, etc.
 Identifiers Naming Rules

• Identifier in Java is composed of a sequence of characters, where each

character can be either a letter, a digit, an underscore (_), or any currency
symbol (such as $, ¢, ¥, or £).
• However, the first character in an identifier cannot be a digit.
• Identifiers in Java are case sensitive.
 Examples of Legal Identifiers

number
Number
sum_$
bingo
$$_100
mål
grüß
 Examples of Illegal Identifiers

48chevy // starts with a digit

all@hands // character @ is not a legal character
grand-sum. // - is also not a legal character
 Keywords

• Keywords are reserved identifiers that are predefined in the language and
cannot be used to denote other entities.
• All the keywords are in lowercase.
• Keywords cannot be used as identifiers.
 Keywords

abstract default implements protected throw

assert do import public throws
boolean double instanceof return transient
break else int short try
byte extends interface static void
case final long strictfp volatile
catch finally native super while
char float new switch

class for package synchronized

continue if private this

 Reserved Literals in Java

• Three identifiers are reserved as predefined literals in the language:

– the null reference and
– the Boolean literals true and false
 Reserved Keywords not Currently in Use

const
goto
 Literals

• A literal denotes a constant value.

• The value a literal represents remains unchanged in the program.
• Literals represent numerical (integer or floating-point), character, boolean or
string values.
• There is literal null that represents the null reference.
 Examples of Literals

Integer 2000 0 -7

Floating-point 3.14 -3.14 .5 0.5

Character 'a' 'A' '0' ':' '-' ')'

Boolean true false

String "abba" "3.14" "for" "a piece of the action"

 Integer Literals

• Integer data types are comprised of the following primitive data types: int,
long, byte, and short.
• The default data type of an integer literal is always int, but it can be
specified as long by appending the suffix L (or l) to the integer value.
• There is no direct way to specify a short or a byte literal.
 Integer Literals (Contd.)

• Integer literals can also be specified in octal (base 8) and hexadecimal (base
16) number systems.
• Octal and hexadecimal numbers are specified with 0 and 0x (or 0X) prefix
respectively.
• The hexadecimal digits from a to f can also be specified with the
corresponding uppercase forms (A to F).
• Negative integers can be specified by prefixing the minus sign (-) to the
magnitude of the integer regardless of number system
• Java does not support literals in binary notation.
 Integer Literals

Decimal Octal Hexadecimal

8 010 0x8
10L 012L 0XaL
16 020 0x10
27 033 0x1B
90L 0132L 0x5aL
-90 -0132 -0X5A
2147483647 (i.e., 231-1) 017777777777 0x7fffffff
-2147483648 (i.e., -231) -020000000000 -0x80000000
1125899906842624L 040000000000000000L 0x4000000000000L
 Floating-point Literal

• Floating-point data types come in two flavors: float or double.

• The default data type of a floating-point literal is double, but it can be
explicitly designated by appending the suffix D (or d) to the value.
• A floating-point literal can also be specified to be a float by appending the
suffix F (or f).
• Floating-point literals can also be specified in scientific notation, where E (or
e) stands for Exponent.
 Examples of double Literals

0.0 0.0d 0D
0.49 .49 .49D
49.0 49. 49D
4.9E+1 4.9E+1D 4.9e1d
4900e-2 .49E2
 Examples of float Literals

0.0F 0f
0.49F .49F
49.0F 49.F 49F
4.9E+1F 4900e-2f .49E2F
 Boolean Literals

• The primitive data type boolean represents the truth-values true or false that
are denoted by the reserved literals true or false, respectively.
 Character Literals

• A character literal is quoted in single-quotes (').

• All character literals have the primitive data type char.
• Characters in Java are represented by the 16-bit Unicode character set
• Any Unicode character can be specified as a four-digit hexadecimal number
(i.e., 16 bits) with the prefix \u.
 Examples of Unicode Values

Character Literal Character Literal using Unicode value Character

'' '\u0020' Space
'0' '\u0030' 0
'1' '\u0031' 1
'9' '\u0039' 9
'A' '\u0041' A
'B' '\u0042' B
'Z' '\u005a' Z
'a' '\u0061' a
'b' '\u0062' b
'z' '\u007a' z
'Ñ' '\u0084' Ñ
'å' '\u008c' å
'ß' '\u00a7' ß
 Escape Sequences

Escape Unicode Value Character

Sequence
\b \u0008 Backspace (BS)
\t \u0009 Horizontal tab (HT or TAB)
\n \u000a Linefeed (LF)
\f \u000c Form feed (FF)
\r \u000d Carriage return (CR)
\' \u0027 Apostrophe-quote
\" \u0022 Quotation mark
\\ \u005c Backslash
 Escape Sequences

Escape Sequence \ddd Character Literal

'\141' 'a'

'\46' '&'

'\60' '0'
 String Literals

• A string literal is a sequence of characters, which must be quoted in

quotation marks and which must occur on a single line.
• All string literal are objects of the class String
• Escape sequences as well as Unicode values can appear in string literals.
 Example of String Literals

• "Here comes a tab.\t And here comes another one\u0009!"

• "What's on the menu?"
• "\"String literals are double-quoted.\""
• "Left!\nRight!"
 White Spaces

• A white space is a sequence of spaces, tabs, form feed and line terminator
characters in a Java source file.
• Line terminators can be newline, carriage return, or carriage return-newline
sequence.
• A Java program is a free-format sequence of characters that is tokenized by
the compiler.
• White space aids not only in separating tokens, but also in formatting the
program so that it is easy for humans to read.
• The compiler ignores the white spaces once the tokens are identified.
 Comments

• A single-line comment: // ... to the end of the line

• A multiple-line comment: /* ... */
• A documentation (Javadoc) comment: /** ... */
 Which of the following is not a legal identifier?

Select the one correct answer.

1. a2z
2. ödipus
3. 52pickup
4. _class
5. ca$h
6. total$
 Which statement is true?

Select the one correct answer.

1. new and delete are keywords in the Java language.
2. try, catch, and thrown are keywords in the Java language.
3. static, unsigned, and long are keywords in the Java language.
4. exit, class, and while are keywords in the Java language.
5. return, goto, and default are keywords in the Java language.
6. for, while, and next are keywords in the Java language.
 Is this a complete and legal comment?

/* // */
Select the one correct answer.
1. No, the block comment (/* ... */) is not ended since the single-line comment
(// ...) comments out the closing part.
2. It is a completely valid comment. The // part is ignored by the compiler.
3. This combination of comments is illegal and the compiler will reject it.
Primitive Data Types
 Primitive Data Types

• Primitive data values are not objects.

• Each primitive data type defines the range of values in the data type, and
operations on these values are defined by operators in the language.
• Each primitive data type also has a corresponding wrapper class that can be
used to represent a primitive value as an object.
 Integer Types

Data Width Minimum value Maximum value

Type (bits) MIN_VALUE MAX_VALUE
byte 8 -27 (-128) 27-1 (+127)
short 16 -215 (-32768) 215-1 (+32767)

int 32 -231 (-2147483648) 231-1 (+2147483647)

long 64 -263 263-1

(-9223372036854775808L) (+9223372036854775807L)
 Character Types

Data Width Minimum Unicode value Maximum Unicode value

Type (bits)

char 16 0x0 (\u0000) 0xffff (\uffff)

 Floating-point Types

Data Width Minimum Positive Value Maximum Positive Value

Type (bits) MIN_VALUE MAX_VALUE

float 32 1.401298464324817E-45f 3.402823476638528860e+38f

double 64 4.94065645841246544e-324 1.79769313486231570e+308

 Boolean Types

Data Type Width (bits) True Value Literal False Value Literal

boolean 1 true false

Which of the following do not denote a primitive data value in
Java?

Select the two correct answer.

1. "t"
2. 'k'
3. 50.5F
4. "hello"
5. false
Which of the following primitive data types are not integer
types?

Select the three correct answer.

1. Type boolean
2. Type byte
3. Type float
4. Type short
5. Type double
Which integral type in Java has the exact range from -2147483648 (-231) to
2147483647 (231-1), inclusive?

Select the one correct answer.

1. Type byte
2. Type short
3. Type int
4. Type long
5. Type char
Declaring and Initializing Variables

• Variable declarations are used to specify the type and the name of variables.
• This implicitly determines their memory allocation and the values that can
be stored in them.
1. Declaring and Initializing Variables
2. Object Reference Variables
3. Lifetime of Variables
1. Instance variables
2. Static variables
3. Local variables
Default Values for Fields

Data Type Default Value

boolean false
char '\u0000'
Integer (byte, short, int, long) 0L for long, 0 for others

Floating-point (float, double) 0.0F or 0.0D

Reference types null

Which of the following lines are valid declarations?

Select the three correct answer.

1. char a = '\u0061';
2. char 'a' = 'a';
3. char \u0061 = 'a';
4. ch\u0061r a = 'a';
5. ch'a'r a = 'a';
Given the following code within a method, which statement is
true?

int a, b;
b = 5;
Select the one correct answer.
1. Local variable a is not declared.
2. Local variable b is not declared.
3. Local variable a is declared but not initialized.
4. Local variable b is declared but not initialized.
5. Local variable b is initialized but not declared.
In which of these variable declarations will the variable
remain uninitialized unless explicitly initialized?

Select the one correct answer.

1. Declaration of an instance variable of type int.
2. Declaration of a static variable of type float.
3. Declaration of a local variable of type float.
4. Declaration of a static variable of type Object.
5. Declaration of an instance variable of type int[].
What will be the result of attempting to compile this class?

import java.util.*;
package com.acme.toolkit;
public class AClass
{
public Other anInstance;
}
class Other
{
int value;
}
Select the one correct answer.

1. The class will fail to compile, since the class Other has not yet been
declared when referenced in class AClass.
2. The class will fail to compile, since import statements must never be at the
very top of a file.
3. The class will fail to compile, since the package declaration can never
occur after an import statement.
4. The class will fail to compile, since the class Other must be defined in a
file called Other.java.
5. The class will fail to compile, since the class Other must be declared
public.
6. The class will compile without errors.
Is an empty file a valid source file?

• Answer true or false.

Which of the following are reserved keywords?

Select the three correct answers.

1. public
2. static
3. void
4. main
5. String
6. args
Which of these are valid declarations of the main() method in
order to start the execution of a Java application?

Select the two correct answer.

1. static void main(String[] args) { /* ... */ }
2. public static int main(String[] args) { /* ... */ }
3. public static void main(String args) { /* ... */ }
4. final public static void main(String[] arguments) { /* ... */ }
5. public int main(Strings[] args, int argc) { /* ... */ }
6. static public void main(String args[]) { /* ... */ }
 Operators
• Operators are special symbols that perform specific operations on one, two,
or three operands, and then return a result.
• Operands are variables, constants or literals on which operation is
performed.
• Types of operators:
– unary operator: Requires only one operand
– binary operator: Requires two operands
– ternary operator: Requires three operands
 Operators (Contd.)

• All the binary operators use infix notation, which means that the operator
appears between its operands:
op1 operator op2 //infix notation
• The ternary operator is also infix; each component of the operator appears
between operands:
op1 ? op2 : op3 //infix notation
 Operators (Contd.)

• The unary operators support either prefix or postfix notation.

– Prefix notation means that the operator appears before its operand:
operator op //prefix notation
– Postfix notation means that the operator appears after its operand:
op operator //postfix notation
• Every operators have precedence and associativity.
• Parentheses, ( ), can be used to override precedence and associativity.
 Operators (Contd.)

• All binary operators, except relational and assignment operators are L-R
associative.
• The relational operators are non-associative.
• Except for unary postfix increment and decrement operators, all unary
operators & all assignment operators are R-L associative.
 Operators (Contd.)

• Java guarantees that all operands of an operator are fully evaluated before
the operator is applied. The only exceptions are the short-circuit conditional
operators &&, ||, and ?:.

int b = 10;
System.out.println((b=3) + b);
The value printed will be 6 and not 13
 Unary Cast Operator: (type)

(<type>) <expression>
- Casting can be applied to primitive values as well as references.
- Casting between primitive data types and reference types is not permitted.
- Boolean values cannot be cast to other data values, and vice versa.
- The reference literal null can be cast to any reference type.
Narrowing and Widening Conversions
 Assignment Operator (=)

• The assignment statement has the following syntax:

<variable> = <expression>
• The destination, <variable>, gets the value of the source, <expression>.
• The previous value of the destination variable is overwritten by the
assignment operator =.
• The destination <variable> and the source <expression> must be type
compatible.
• The destination variable must also have been declared.
• Since variables can store either primitive data values or object references,
<expression> evaluates to either a primitive data value or an object
reference.
 Assignment Operator (=)

• Assigning primitive values

• Assigning references
• Multiple Assignments
Given char c = 'A';
What is the simplest way to convert the character value in c into an int?
Select the one correct answer.
a. int i = c;
b. int i = (int) c;
c. int i = Character.getNumericValue(c);
What will be the result of attempting to compile and run the following class?
public class Assignment
{
public static void main(String[ ] args)
{
int a, b, c;
b = 10;
a = b = c = 20;
System.out.println(a);
}
}
Select the one correct answer.
a. The code will fail to compile, since the compiler will recognize that the
variable c in the assignment statement a = b = c = 20; has not been initialized.
b. The code will fail to compile because the assignment statement a = b = c =
20; is illegal.
c. The code will compile correctly and will display 10 when run.
d. The code will compile correctly and will display 20 when run.
What will be the result of attempting to compile and run the following program?
public class MyClass
{
public static void main(String[ ] args)
{
String a, b, c;
c = new String("mouse");
a = new String("cat");
b = a;
a = new String("dog");
c = b;
System.out.println(c);
}
}
Select the one correct answer.
a. The program will fail to compile.

b. The program will print mouse when run.

c. The program will print cat when run.

d. The program will print dog when run.

e. The program will randomly print either cat or dog when run.
 Arithmetic Operators

• The arithmetic operators are used to construct mathematical expressions as in

algebra.
• Their operands are of numeric type (which includes the char type).
• Unary operators have right associativity and binary have left associativity.

Unary + Addition - Subtraction

Binary * Multiplication / Division % Remainder
+ Addition - Subtraction
Operator Use Description
Adds op1 and op2; also used to concatenate
+ op1 + op2
strings
- op1 - op2 Subtracts op2 from op1
* op1 * op2 Multiplies op1 by op2
/ op1 / op2 Divides op1 by op2

Computes the remainder of dividing op1 by op2.

% op1 % op2 Note that the sign of result is the sign of first
operand.
class ArithmeticOperators{
public static void main(String args[]){
int i=5,j=6;
System.out.println(i+j);
System.out.println(i-j);
System.out.println(i*j);
System.out.println(i/j);
System.out.println(i%j);
double a=5.5,b=2.0;
System.out.println(a+b);
System.out.println(a-b);
System.out.println(a*b);
System.out.println(a/b);
System.out.println(a%b);
System.out.println(5%2);
System.out.println(-5%2);
System.out.println(5%-2);
System.out.println(-5%-2);
}
}
The necessary conversions take place before the operation is performed

Data Type Data Type of Operands

of Result
Neither operand is a float or a double and at least one operand is a
long
long.
Neither operand is a float or a double and neither operand is a
int
long.
double At least one operand is a double.
float At least one operand is a float and neither operand is a double.
Which of the following expressions will be evaluated using floating-point
arithmetic?
Select the three correct answers.
a. 2.0 * 3.0
b. 2 * 3
c. 2/3 + 5/7
d. 2.4 + 1.6
e. 0x10 * 1L * 300.0
What is the value of the expression (1 / 2 + 3 / 2 + 0.1)?
Select the one correct answer.
a. 1
b. 1.1
c. 1.6
d. 2
e. 2.1
What will be the result of attempting to compile and run the following
program?
public class Integers
{
public static void main(String[] args)
{
System.out.println(0x10 + 10 + 010);
}
}
Select the one correct answer.
a. The program will not compile. The compiler will complain about the
expression 0x10 + 10 + 010.
b. When run, the program will print 28.
c. When run, the program will print 30.
d. When run, the program will print 34.
e. When run, the program will print 36.
f. When run, the program will print 101010.
Which of the following expressions are valid?
Select the three correct answers.
a. (- 1 -)
b. (+ + 1)
c. (+-+-+-1)
d. (--1)
e. (1 * * 1)
f. (- -1)
What is the value of evaluating the following expression
(- -1-3 * 10 / 5-1)?
Select the one correct answer.
a. –8
b. –6
c. 7
d. 8
e. 10
f. None of the above.
Which of these assignments are valid?
Select the four correct answers.
a. short s = 12;
b. long l = 012;
c. int other = (int) true;
d. float f = -123;
e. double d = 0x12345678;
 Binary String Concatenation Operator (+)

• The binary operator + is overloaded.

• When one of the operands is a String object, the other operand is implicitly
converted to its string representation and string concatenation is performed.
 Binary String Concatenation Operator (+)

• For a operand of a primitive data type, its value is converted to a String object
with the string representation of the value.
• Values like true, false, and null are represented by string representations of
these literals.
• A reference variable with the value null also has the string representation
"null" in this context.
• For all reference value operands, a string representation is constructed by
calling the toString() method on the referred object.
 Binary String Concatenation Operator (+)

String theName = " Uranium";

theName = " Pure" + theName; // " Pure Uranium"
String trademark1 = 100 + "%" + theName;
// "100% Pure Uranium"

String trademark2 = 100 + '%' + theName;

// "137 Pure Uranium"

System.out.println("We put 2 and 2 together and get " + 2 + 2);

// We put 2 and 2 together and get 22
 Increment and Decrement Operator: ++,--

• ++i adds 1 to i first, then uses the new value of i as the value of the expression.
i += 1;
result = i;
return result;
• j++ uses the current value of j as the value of the expression first, then adds 1
to j.
result = j;
j += 1;
return result;
 Increment and Decrement Operator: ++,--

int i = 10;
int k = ++i + --i;
--i;

long i = 10;
long k = i++ + i--;
// ((i++) + (i--)). k gets the value 21L and i becomes 10L.
i++;

byte b = 10;
int i = ++b;

double x = 4.5;
x = x + ++x;
 Relational Operators

a<b a less than b?

a <= b a less than or equal to b?
a>b a greater than b?
a >= b a greater than or equal to b?

a and b represent numeric expressions

 Note

• All relational operators are binary operators

• Their operands are numeric expressions.
• Binary numeric promotion is applied to the operands of these operators.
• The evaluation results in a boolean value.
• Relational operators have precedence lower than arithmetic operators, but
higher than that of the assignment operators.
double hours = 45.5;

boolean overtime = hours >= 35.0; // true.

boolean order = 'A' < 'a';

// true. Binary numeric promotion applied.

• Relational operators are non-associative. Mathematical expressions like a 
b c must be written using relational and boolean logical/conditional
operators.

int a = 1, b = 7, c = 10;
boolean valid1 = a <= b <= c; // Illegal.
boolean valid2 = a <= b && b <= c; // OK.
 Primitive Data Value Equality: ==, !=

a == b a and b are equal? That is, have the same primitive value? (Equality)
a != b a and b are not equal? That is, do not have the same primitive value?
(Inequality)

Given that a and b represent operands of primitive data types

Binary numeric promotion is applied to the non-boolean operands of these

equality operators.
int year = 2002;
boolean isEven = year % 2 == 0; // true.
boolean compare = '1' == 1;
// false. Binary numeric promotion applied.
boolean test = compare == false; // true.

int a, b, c;
a = b = c = 5;
boolean valid1 = a == b == c; // (1) Illegal.
boolean valid2 = a == b && b == c; // (2) Legal.
boolean valid3 = a == b == true; // (3) Legal.
 Object Reference Equality: ==, !=
The equality operator == and the inequality operator != can be applied to
object references to test whether they denote the same object.

a == b a and b are equal? That is, have the same reference value? (Equality)
a != b a and b are not equal? That is, do not have the same reference value?
(Inequality)

Given that a and b represent operands of reference types

 Boolean Logical Operators: !, ^, &, |

Logical complement !x Returns the complement of the truth-value of x.

Logical AND x&y true if both operands are true; otherwise, false.
Logical OR x|y true if either or both operands are true;
otherwise, false.
Logical XOR x^y true if and only if one operand is true; otherwise,
false.

Given that x and y represent boolean expressions

These operators always evaluate both the operands, unlike their counterpart
conditional operators && and ||
Truth-values for Boolean Logical Operators

x y !x x&y x|y x^y

true true false true true false

true false false false true true
false true true false true true
false false true false false false
Boolean Logical Compound Assignment Operators
Expression: Given b and a Are of Type Boolean, the Expression Is
Evaluated as:
b &= a b = (b & (a))
b ^= a b = (b ^ (a))
b |= a b = (b | (a))

boolean b1 = false, b2 = false, b3 = false;

b1 |= true; // true
b2 ^= b1; // true
b3 &= b1 | b2; // (1) false. b3 = (b3 & (b1 | b2)).
b3 = b3 & b1 | b2; // (2) true. b3 = ((b3 & b1) | b2).
 Conditional Operators: &&, ||

Conditional AND x && y true if both operands are true; otherwise, false.
Conditional OR x || y true if either or both operands are true;
otherwise, false.

Given that x and y represent values of boolean expressions

Unlike their logical counterparts & and |, which can also be applied to integral
operands for bitwise operations, the conditional operators && and || can only
be applied to boolean operands.
 Truth-values for Conditional Operators
x y x && y x || y
true true true true
true false false true
false true false true
false false false false

In evaluation of boolean expressions involving conditional AND & OR, the left-
hand operand is evaluated before the right one, and the evaluation is short-
circuited (i.e., if the result of the boolean expression can be determined from the
left-hand operand, the right-hand operand is not evaluated).
The binary conditional operators have precedence lower than either arithmetic,
relational, or logical operators, but higher than assignment operators.

boolean b1 = 4 == 2 && 1 < 4; // false, short-circuit evaluated as

// (b1 = ((4 == 2) && (1 < 4)))
boolean b2 = !b1 || 2.5 > 8; // true, short-circuit evaluated as
// (b2 = ((!b1) || (2.5 > 8)))
boolean b3 = !(b1 && b2); // true
boolean b4 = b1 || !b3 && b2; // false, short-circuit evaluated as
// (b4 = (b1 || ((!b3) && b2)))

if (objRef != null && objRef.doIt()) { /*...*/ }

if (i > 0 && i++ < 10) {/*...*/} // i is not incremented if i > 0 is false.
if (i > 0 || i++ < 10) {/*...*/} // i is not incremented if i > 0 is true.
 Integer Bitwise Operators: ~, &, |, ^

• The binary bitwise operators perform bitwise operations between

corresponding individual bit values in the operands.
• Unary numeric promotion is applied to the operand of the unary bitwise
complement operator ~, and binary numeric promotion is applied to the
operands of the binary bitwise operators.
• The result is a new integer value of the promoted type, which can only be
either int or long.
 Integer Bitwise Operators

Operator Name Notation Effect on Each Bit of the Binary

Representation
Bitwise complement ~A Invert the bit value: 1 to 0, 0 to 1.
Bitwise AND A&B 1 if both bits are 1; otherwise, 0.
Bitwise OR A|B 1 if either or both bits are 1; otherwise, 0.
Bitwise XOR A^B 1 if and only if one of the bits is 1;
otherwise, 0.
 Result Table for Bitwise Operators

A B ~A A&B A|B A^B

1 1 0 1 1 0
1 0 0 0 1 1
0 1 1 0 1 1
0 0 1 0 0 0

char v1 = ')'; // Unicode value 41

byte v2 = 13;
int result1 = ~v1; // -42
int result2 = v1 & v2; // 9
int result3 = v1 | v2; // 45
int result4 = v1 ^ v2; // 36
 Bitwise Compound Assignment Operators
Expression: Given T Is the Integral Type of b, the Expression Is Evaluated
as:
b &= a b = (T) ((b) & (a))
b ^= a b = (T) ((b) ^ (a))
b |= a b = (T) ((b) | (a))

int v0 = -42;
char v1 = ')'; // 41 byte
byte v2 = 13;
v0 &= 15; // 1...1101 0110 & 0...0000 1111 => 0...0000 0110 (= 6)
v1 |= v2; // (1) 0...0010 1001 | 0...0000 1101 => 0...0010 1101 (= 45)
 Shift Operators: <<, >>, >>>

• The binary shift operators form a new value by shifting bits either left or right a
specified number of times in a given integral value.
• The number of shifts (also called the shift distance) is given by the right-hand
operand, and the value that is to be shifted is given by the left-hand operand.
• Note that unary numeric promotion is applied to each operand individually.
• The shift distance is calculated by AND-ing the value of the right-hand operand
with a mask value of 0x1f (31) if the left-hand has the promoted type int, or
using a mask value of 0x3f (63) if the left-hand has the promoted type long.
 Shift Operators

Shift left a << n Shift all bits in a left n times, filling with 0
from the right.
Shift right with sign bit a >> n Shift all bits in a right n times, filling with the
sign bit from the left.
Shift right with zero fill a >>> n Shift all bits in a right n times, filling with 0
from the left.

Given that a contains the value whose bits are to be shifted and n specifies the
number of bits to shift
int i = 12;
int result = i << 4; // 192

i << 4
= 0000 0000 0000 0000 0000 0000 0000 1100 << 4
= 0000 0000 0000 0000 0000 0000 1100 0000
= 0x000000c0
= 192
byte b = -42; // 11010110
short n = 4;
int result = b << n; // -672
byte a = 32, b;
int j;
j = a << 3; // 256
b = (byte) (a << 3); // 0. Cast mandatory.

a << 3
= 0000 0000 0000 0000 0000 0000 0010 0000 << 3
= 0000 0000 0000 0000 0000 0001 0000 0000
= 0x00000100
= 256
int i = 12;
int result = i >> 2; // 3
i >> 2
= 0000 0000 0000 0000 0000 0000 0000 1100 >> 2
= 0000 0000 0000 0000 0000 0000 0000 0011
= 0x00000003
=3
byte b = -42; // 11010110

int result = b >> 4; // -3

b >> 4

= 1111 1111 1111 1111 1111 1111 1101 0110 >> 4

= 1111 1111 1111 1111 1111 1111 1111 1101

= 0xfffffffd

= -3
byte b = -42; // 1101 0110

int result = b >>> 4; // 268435453

b >>> 4

= 1111 1111 1111 1111 1111 1111 1101 0110 >>> 4

= 0000 1111 1111 1111 1111 1111 1111 1101

= 0x0ffffffd

= 268435453
 Shift Compound Assignment Operators: <<=, >>=, >>>=

Expression Given T as the Integral Type of x, the Expression Is

Evaluated as:

x <<= a x = (T) ((x) << (a))

x >>= a x = (T) ((x) >> (a))

x >>>= a x = (T) ((x) >>> (a))

int i = -42;
i >>= 4; // 1...1101 0110 >> 4 => 1...1111 1101 (= -3).
byte a = 12; a <<= 5; // (1) -128. Evaluated as a = (byte)((int)a << 5)
a = a << 5; // Compile-time error. Needs explicit cast.

a = (byte) (a << 5)
= (byte) (0000 0000 0000 0000 0000 0000 0000 1100 << 5)
= (byte) 0000 0000 0000 0000 0000 0001 1000 0000
= 1000 0000
= 0x80
= -128
 The Conditional Operator: ?

<condition> ? <expression1> : <expression2>

• If the boolean expression <condition> is true then <expression1> is
evaluated; otherwise, <expression2> is evaluated.
• The value of the expression evaluated is returned by the conditional
expression.
boolean leapYear = false;
int daysInFebruary = leapYear ? 29 : 28; // 28
• The conditional operator is the expression equivalent of the if-else
statement.
• The conditional expression can be nested and the conditional operator
associates from right to left:
• (a?b?c?d:e:f:g) evaluates as (a?(b?(c?d:e):f):g)
 Other Operators: new, [ ], instanceof

• The new operator is used to create objects, that is, instances of classes and
arrays.
• It is used with a constructor call to instantiate classes, and with the [ ]
notation to create arrays.
• It is also used to instantiate anonymous arrays, and anonymous classes.
Pizza onePizza = new Pizza();
// Create an instance of Pizza class.
 Other Operators: new, [ ], instanceof

• The [ ] notation is used to declare and construct arrays and also to access
array elements.
int[ ] anArray = new int[5];
// Declare and construct an int array of 5 elements.
anArray[4] = anArray[3];
// Element at index 4 gets value of element at index 3.
 Other Operators: new, [ ], instanceof

• The boolean, binary, and infix operator instanceof is used to test an object's
type.
Pizza myPizza = new Pizza();
boolean test1 = myPizza instanceof Pizza; // True.
boolean test2 = "Pizza" instanceof Pizza;
// Compile error. String is not Pizza.
boolean test3 = null instanceof Pizza;
// Always false. null not an instance.
 Control Flow Statements

• Control flow statements govern the flow of control in a program during

execution i.e. the order in which statements are executed in a running
program.
• There are three main categories of control flow statements:
– Selection statements: if, if-else and switch.
– Iteration statements: while, do-while and for.
– Transfer statements: break, continue, return, try-catch-finally and assert.
 Selection Statements

• Selection statements allow the program to choose between alternative

actions during execution.
 Simple if Statement

if (<conditional expression>)
<statement>
• It is used to decide whether an action is to be performed or not, based on a
condition.
• The condition is specified by <conditional expression> and the action to be
performed is specified by <statement>.
• The <conditional expression> is evaluated first. If its value is true, then
<statement> (called the if block) is executed and execution continues with
the rest of the program. If the value is false, then the if block is skipped and
execution continues with the rest of the program.
if(emergency) // emergency is a boolean variable
operate();

if(temperature > critical)

soundAlarm();

if(isLeapYear() && endOfCentury())

celebrate();

if(catIsAway())
{
// Block
getFishingRod();
goFishing();
}
if(emergency); // Empty if block
operate(); // Executed regardless of whether it was
// an emergency or not.

if(a=b) // Assignment allowed only if a & b are boolean

{} // Empty block allowed
 if-else Statement

if (<conditional expression>)
<statement1>
else
<statement2>

The <conditional expression> is evaluated first. If its value is true, then

<statement1> (the if block) is executed and execution continues with the rest
of the program. If the value is false, then <statement2> (the else block) is
executed and execution continues with the rest of the program.
if(emergency) if(catIsAway())
operate(); {
else
getFishingRod();
joinQueue();
goFishing();
}
if(temperature > critical)
soundAlarm(); else
else playWithCat();
businessAsUsual();
 Cascading if-else

• Cascading if-else statements are a sequence of nested if-else statements

where the if of the next if-else statement is joined to the else clause of the
previous one.
• The decision to execute a block is then based on all the conditions evaluated
so far.
 switch Statement

• The switch statement can be used to choose one among many alternative
actions, based on the value of an expression.
switch (<non-long integral expression>) {
case label1: <statement1>
case label2: <statement2>
...

case labeln: <statementn>

default: <statement>
} // end switch
 switch Statement

• The syntax of the switch statement comprises a switch expression followed

by the switch body, which is a block of statements.
• The type of the switch expression is non-long integral (i.e., char, byte, short,
or int).
• The statements in the switch body can be labeled, defining entry points in
the switch body where control can be transferred depending on the value of
the switch expression.
 switch Statement

• The switch expression is evaluated first.

• The value of the switch expression is compared with the case labels.
• Control is transferred to the <statementi> associated with the case label that
is equal to the value of the switch expression. After execution of the
associated statement, control falls through to the next statement unless
appropriate action is taken.
• If no case label is equal to the value of the switch expression, the statement
associated with the default label is executed.
 switch Statement
• All labels (including the default label) are optional and can be defined in
any order in the switch body.
• There can be at most one default label in a switch statement.
• If it is left out and no valid case labels are found, the whole switch
statement is skipped.
• The case labels are constant expressions whose values must be unique,
meaning no duplicate values are allowed.
• The case label values must be assignable to the type of the switch
expression
• Note that the type of the case label cannot be boolean, long, or floating-
point.
 Iteration Statements

• Loops allow a block of statements to be executed repeatedly.

• A boolean condition (called the loop condition) is commonly used to
determine when to terminate the loop.
• The statements executed in the loop constitute the loop body.
• The loop body can be a single statement or a block.
• Types of loops:
– while statement
– do-while statement
– for statement
• These loops differ in the order in which they execute the loop body and test
the loop condition.
• The while and the for loops test the loop condition before executing the loop
body, while the do-while loop tests the loop condition after execution of the
loop body.
 while Statement
while (<loop condition>)
<loop body>
• The loop condition is evaluated before executing the loop body.
• The while statement executes the loop body as long as the loop condition is
true. When the loop condition becomes false, the loop is terminated and
execution continues with the statement immediately following the loop.
• If the loop condition is false to begin with, the loop body is not executed at all
i.e. a while loop can execute zero or more times.
• The loop condition must be a boolean expression.
• The while statement is normally used when the number of iterations is not
known a priori.
while(noSignOfLife())
keepLooking();

while (noSignOfLife()); // Empty statement as loop body!

keepLooking(); // Statement not in the loop body.
 do-while Statement
do
<loop body>
while (<loop condition>);

• The loop condition is evaluated after executing the loop body.

• The do-while statement executes the loop body until the loop condition
becomes false.
• When the loop condition becomes false, the loop is terminated and execution
continues with the statement immediately following the loop.
• Note that the loop body is executed at least once.
while (cat.isAway()){ // (1)
mice.play();
}

do{ // (2)
mice.play();
} while (cat.isAway());
 for Statement
for(<initialization>; <loop condition>; <increment expression>)
<loop body>
• It is mostly used for counter-controlled loops, that is, when the number of
iterations is known beforehand.
• The <initialization> usually declares and initializes a loop variable that
controls the execution of the <loop body>.
• The <loop condition> is a boolean expression, usually involving the loop
variable, such that if the loop condition is true, the loop body is executed;
otherwise, execution continues with the statement following the for loop.
• After each iteration (i.e., execution of the loop body), the <increment
expression> is executed. This usually modifies the value of the loop variable
to ensure eventual loop termination.
• The loop condition is then tested to determine if the loop body should be
executed again.
• Note that the <initialization> is only executed once on entry to the loop.
int sum = 0;

int[] array = {12, 23, 5, 7, 19};

for(int index = 0; index < array.length; index++)

sum += array[index];
 Transfer Statements

• break
• continue
• return
• try-catch-finally
• throw
• assert
• Note that Java does not have a goto statement, although goto is a reserved
word.
 Labeled Statements

<label> : <statement>
• A label is any valid identifier and it always immediately proceeds the
statement.
• Label names exist in their own name space, so that they do not conflict with
names of packages, classes, interfaces, methods, fields, and local variables.
• The scope of a label is the statement prefixed by the label, meaning that it
cannot be redeclared as a label inside the labeled statement—analogous to
the scope of local variables.
• A statement can have multiple labels:

LabelA: LabelB: System.out.println("Mutliple labels");

• A declaration statement cannot have a label:

L0: int i = 0; // Compile time error.

• A labeled statement is executed like it was non-labeled, unless it contains

the break or continue statements.
 break Statements

break; // the unlabeled form

break <label>; // the labeled form
• The unlabeled break statement terminates loops (for, while, do-while) and
switch statements which contain the break statement, and transfers control
out of the current context (i.e., the closest enclosing block).
class BreakOut
{
public static void main(String[ ] args)
{
for(int i = 1; i <= 5; ++i)
{
if(i == 4) break;
System.out.println(i + "\t" + Math.sqrt(i));
}
 int n = 2;
switch(n)
{
case 1:
System.out.println(n);
break;
case 2:
System.out.println("Inner for loop: ");
for (int j = 0; j < n; j++)
if(j == 2)
break; /
else
System.out.println(j);
default: System.out.println("default: " + n);
}
}
}
• A labeled break statement can be used to terminate any labeled statement
that contains the break statement.

• Control is then transferred to the statement following the enclosing labeled

statement.
class LabeledBreakOut
{
public static void main(String[] args)
{
int[][] squareMatrix = {{4, 3, 5}, {2, 1, 6}, {9, 7, 8}};
int sum = 0;
outer:for(int i = 0; i < squareMatrix.length; ++i)
{
for (int j = 0; j < squareMatrix[i].length; ++j)
{
if(j == i) break;
System.out.println("Element[" + i + ", " + j + "]: " +
squareMatrix[i][j]);
sum += squareMatrix[i][j];
if (sum > 10) break outer;
}
}
System.out.println("sum: " + sum);
}
}
 continue Statements

continue; // the unlabeled form

continue <label>; // the labeled form
• The continue statement can only be used in a for, while, or do-while loop to
prematurely stop the current iteration of the loop body and proceed with
the next iteration, if possible.
class Skip
{
public static void main(String[ ] args)
{
for(int i = 1; i <= 5; ++i)
{
if(i == 4) continue;
System.out.println(i + "\t" + Math.sqrt(i));
}
}
}
• A labeled continue statement must occur within a labeled loop that has the
same label.

• Execution of the labeled continue statement then transfers control to the

end of that enclosing labeled loop.
class LabeledSkip
{
public static void main(String[] args)
{
int[][] squareMatrix = {{4, 3, 5}, {2, 1, 6}, {9, 7, 8}};
int sum = 0;
outer:for(int i = 0; i < squareMatrix.length; ++i)
{
for (int j = 0; j < squareMatrix[i].length; ++j)
{
if(j == i) continue;
System.out.println("Element[" + i + ", " + j + "]: " +
squareMatrix[i][j]);
sum += squareMatrix[i][j];
if (sum > 10) continue outer;
}
}
System.out.println("sum: " + sum);
}
}
 return Statements

• The return statement is used to stop execution of a method and transfer

control back to the calling code.

Form of return Statement In void Method In Non-void Method

return; optional not allowed

return <expression>; not allowed mandatory
 Arrays

• An array is a data structure that defines an indexed collection of a fixed number

of homogeneous data elements.
• All elements in the array have the same data type.
• A position in the array is indicated by a non-negative integer value called the
index.
• An element at a given position in the array is accessed using the index.
 Arrays

• The size of an array is fixed and cannot increase to accommodate more elements.
• In Java, arrays are objects.
• Arrays can be of primitive data types or reference types.
• Each array object has a final field called length, which specifies the array size,
that is, the number of elements the array can accommodate.
 Arrays

• The first element is always at index 0 and the last element at index n-1, where n
is the value of the length field in the array.
• Simple arrays are one-dimensional arrays, that is, a simple sequence of values.
• Since arrays can store object references, the objects referenced can also be array
objects. This allows implementation of array of arrays.
 Declaring Array Variables

<element type>[ ] <array name>;

or
<element type> <array name>[ ];
• Where <element type> can be a primitive data type or a reference type.
• The array variable <array name> has the type <element type>[].
• Note that the array size is not specified. This means that the array variable
<array name> can be assigned an array of any length, as long as its elements
have <element type>.
int anIntArray[ ], oneInteger;
Pizza[ ] mediumPizzas, largePizzas;
 Constructing an Array

<array name> = new <element type> [<array size>];

• The minimum value of <array size> is 0 (i.e., arrays with zero elements can be
constructed in Java).
• If the array size is negative, a NegativeArraySizeException is thrown.
The array declaration and construction can be combined.

<element type1>[ ] <array name> =

new <element type2>[<array size>];

- However, here array type <element type2>[ ] must be assignable to array

type <element type1>[ ].
- When the array is constructed, all its elements are initialized to the default
value for <element type2>. This is true for both member and local arrays
when they are constructed.
 Initializing an Array

• Java provides the means of declaring, constructing, and explicitly

initializing an array in one declaration statement:
<element type>[ ] <array name> = {<array initialize list>};
• This form of initialization applies to member as well as local arrays.
• The <array initialize list> is a comma-separated list of zero or more
expressions.
int[ ] anIntArray = {1, 3, 49, 2, 6, 7, 15, 2, 1, 5};
// Pizza class extends Object class
Object[] objArray = { new Pizza(), new Pizza(), null };
 Initializing an Array

• The expressions in the <array initialize list> are evaluated from left to right.
• The following array has length two, not three:
• Topping[] pizzaToppings = { new Topping("cheese"), new
Topping("tomato"), };
• // Array with 3 String objects
String[] pets = {"crocodiles", "elephants", "crocophants―};
• // Array of 3 characters
char[] charArray = {'a', 'h', 'a'}; // Not the same as "aha".
 Using an Array

• The array element can be accesses using following syntax:

<array name> [<index expression>]
• The <index expression> can be any expression that evaluates to an non-
negative int value.
• At runtime, the index value is automatically checked to ensure that it is
within the array index bounds.
• If the index value is less than 0 or greater than or equal to <array
name>.length in an array element access expression, an
ArrayIndexOutOfBoundsException is thrown.
 Using an Array

• The <array name> can, in fact, be any expression that returns a reference to
an array.
"AHA".toCharArray()[1].
• The array operator [ ] is used to declare array types, specify array size, and
to access array elements.
• This operator is not used when the array reference is manipulated, for
example in an array reference assignment or when the array reference is
passed as an actual parameter in a method call.
 Anonymous Arrays

new <element type>[ ] {<array initialize list>}

new int[ ] {3, 5, 2, 8, 6}

• The construct creates a nameless array of a specific type.

• Neither the name of the array nor the size of the array is specified.
• The construct returns an array reference that can be assigned and passed as
parameter.
int[] intArray = {3, 5, 2, 8, 6}; // (1)
int[] intArray = new int[] {3, 5, 2, 8, 6}; // (2)
 Anonymous Arrays

int[ ] daysInMonth;
daysInMonth = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; // Not ok.
daysInMonth = new int[ ] {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; // ok.
 Multidimensional Array

• Since an array element can be an object reference and arrays are objects,
array elements can themselves reference other arrays.
• In Java, an array of arrays can be defined as follows:
<element type>[][]...[] <array name>;
or
<element type> <array name>[][]...[];
• The following declarations are all equivalent:
int[][] mXnArray; // 2-dimensional array
int[] mXnArray[]; // 2-dimensional array
int mXnArray[][]; // 2-dimensional array
int[][] mXnArray = new int[4][5]; // 4 x 5 matrix of ints
double[ ][ ] identityMatrix = {
{1.0, 0.0, 0.0, 0.0 }, // 1. row
{0.0, 1.0, 0.0, 0.0 }, // 2. row
{0.0, 0.0, 1.0, 0.0 }, // 3. row
{0.0, 0.0, 0.0, 1.0 } // 4. row
}; // 4 x 4 Floating-point matrix

Pizza[ ][ ] pizzaGalore = {
{new Pizza(), null, new Pizza()},
{null, new Pizza()},
new Pizza[1],
{},
null
};