Java Origins

Computer language innovation and development

occurs for two fundamental reasons:
1) to adapt to changing environments and uses
2)to implement improvements in the art of
programming
The development of Java was driven by both in equal
measures.
Many Java features are inherited from the earlier
languages:
B
C
C++
Java
1

Before Java: C
Designed by Dennis Ritchie in 1970s.
Before C, there was no language to reconcile: easeof-use versus power,safety versus efficiency, rigidity
versus extensibility.
BASIC, COBOL, FORTRAN, PASCAL optimized
one set of traits, but not the other.
C- structured, efficient, high-level language that
could replace assembly code when creating systems
programs.
Designed, implemented and tested by programmers,
not scientists.
2

Before Java: C++

Designed by Bjarne Stroustrup in 1979.
Response to the increased complexity of programs and respective
improvements in the programming paradigms and methods:
1) assembler languages
2) high-level languages
3) structured programming
4) object-oriented programming (OOP)
OOP methodology that helps organize complex programs
through the use of inheritance, encapsulation and polymorphism.
C++ extends C by adding object-oriented features.
3

Java History
Designed by James Gosling, Patrick Naughton, Chris Warth,
Ed Frank and Mike Sheridan at Sun Microsystems in 1991.
The original motivation is not Internet: platform-independent
software embedded in consumer electronics devices.
With Internet, the urgent need appeared to break the fortified
positions ofIntel, Macintosh and Unix programmer
communities.
Java as an Internet version of C++? No.
Java was not designed to replace C++, but to solve a different
set of problems. There are significant practical/philosophical
differences.
4

Java Technology
There is more to Java than the language.
Java Technology consists of:
1) Java Programming Language
2) Java Virtual Machine (JVM)
3) Java Application Programming Interfaces
(APIs)

Java Language Features

1) simple
2) object-oriented
3) robust
4) multithreaded
5) architecture-neutral
6) interpreted and high-performance
7) distributed
8) dynamic
9) secure
6

Java Language Features

1) simple Java is designed to be easy for the
professional programmer to learn and use.
2) object-oriented a clean, usable, pragmatic
approach to objects, not restricted by the need for
compatibility with other languages.
3) robust restricts the programmer to find the
mistakes early, performs compile-time (strong
typing) and run-time (exception-handling) checks,
manages memory automatically.
7

Java Language Features

4) multithreaded supports multi-threaded programming
for writing program that perform concurrent
computations
5) architecture-neutral Java Virtual Machine provides a
platform independent environment for the execution of Java
bytecode
6) interpreted and high-performance Java programs are
compiled into an intermediate representation bytecode:
a) can be later interpreted by any JVM
b) can be also translated into the native machine code for
efficiency.

Java Language Features

7) distributed Java handles TCP/IP protocols,

accessing a resource through its URL much
like accessing a local file.
8) dynamic substantial amounts of run-time
type information to verify and resolve
access to objects at run-time.
9) secure programs are confined to the Java
execution environment and cannot access
other parts of the computer.
9

Execution Platform
What is an execution platform?
1) An execution platform is the hardware or software
environment in which a program
runs, e.g.
Windows 2000, Linux, Solaris or MacOS.
2) Most platforms can be described as a
combination of the operating system and hardware.

10

Java Execution Platform

What is Java Platform?
1) A software-only platform that runs on top of other
hardware-based platforms.
2) Java Platform has two components:
a) Java Virtual Machine (JVM) interpretation
for the Java bytecode, ported onto various
hardware-based platforms.
b) The Java Application Programming Interface
(Java API)
11

Java Platform Independence

12

Java Program Execution

Java programs are both compiled and interpreted:
Steps:
write the Java program
compile the program into bytecode
execute (interpret) the bytecode on the computer
through the Java Virtual Machine
Compilation happens once.
Interpretation occurs each time the program is
executed.
13

Java Execution Process

14

Java API
What is Java API?
1) a large collection of ready-made software
components that provide many useful capabilities,
e.g. graphical user interface
2) grouped into libraries (packages) of related
classes and interfaces
3) together with JVM insulates Java programs
from the hardware and operating system
variations
15

Java Program Types

Types of Java programs:
1) applications standalone (desktop) Java programs,
executed from the command line, only need the
Java Virtual Machine to run
2) applets Java program that runs within a Javaenabled browser, invoked through a applet
reference on a web page, dynamically downloaded to
the client computer
3) servlets Java program running on the web
server, capable of responding to HTTP
requests
made through the network
16

Simple Java Program

A class to display a simple message:
class MyProgram {
public static void main(String args []) {
System.out.println(First Java program.");
}
}

17

Running the Program

Type the program, save as MyProgram.java.
In the command line, type:
> dir
MyProgram.java
> javac MyProgram.java
> dir
MyProgram.java, MyProgram.class
> java MyProgram
First Java program.
18

Explaining the Process

1) creating a source file - a source file contains text written in the
Java programming language, created using any text editor on
any system.
2) compiling the source file - Java compiler (javac) reads the
source file and translates its text into instructions that the Java
interpreter can understand. These instructions are called
bytecode.
3) running the compiled program - Java interpreter (java)
installed takes as input the bytecode file and carries out its
instructions by translating them on the fly into instructions that
your computer can understand.
19

Java Program Explained

MyProgram is the name of the class:
class MyProgram {
main is the method with one parameter args and no
results:
public static void main(String[] args) {
println is a method in the standard System class:
System.out.println(First Java program.");
}
}
20

Classes and Objects

A class is the basic building block of Java programs.
A class encapsulates:
a) data (attributes) and
b) operations on this data (methods)
and permits to create objects as its instances.

21

Main Method
The main method must be present in every Java application:
1) public static void main(String[] args) where:
a)public means that the method can be called by any object
b)static means that the method is shared by all instances
c)void means that the method does not return any value
2) When the interpreter executes an application, it starts by
calling its main method which in turn invokes other methods
in this or other classes.
3) The main method accepts a single argument a string array,
which holds all command-line parameters.

22

Exercise: Java Program

1) Personalize the MyProgram program with your name so that it tells
you
Hello, my name is
2) Write a program that produces the following output:
Welcome to MES College Java Workshop!
I hope you will benefit from the training.
3) Here is a slightly modified version of MyProgram:
class MyProgram2 {
public void static Main(String args) {
system.out.println(First Java Program!);
}
}
The program has some errors. Fix the errors so that the program
successfully compiles and runs. What were the errors?
23

Java Syntax
On the most basic level, Java programs consist of:
a) whitespaces
b) identifiers
c) comments
d) literals
e) separators
f) keywords
g) operators
Each of them will be described in order.
24

Whitespaces
A whitespace is a space, tab or new line.
Java is a form-free language that does not require special
indentation.
A program could be written like this:
class MyProgram {
public static void main(String[] args) {
System.out.println(First Java program.");
}
}
It could be also written like this:
class MyProgram { public static void main(String[] args)
{ System.out.println(First Java program."); } }
25

Identifiers
Java identifiers:
a) used for class names, method names, variable names
b) an identifier is any sequence of letters, digits, _ or $
characters that do not begin with a digit
c) Java is case sensitive, so value, Value and VALUE are all
different.
Seven identifiers in this program:
class MyProgram {
public static void main(String[] args) {
System.out.println(First Java program.");
}
}
26

Comments
Three kinds of comments:
1) Ignore the text between /* and */:
/* text */
2) Documentation comment (javadoc tool uses this kind
of comment to automatically generate software
documentation):
/** documentation */
3) Ignore all text from // to the end of the line:
// text
27

Comments
/**
* MyProgram implements application that displays
* a simple message on the standard output device.
*/
class MyProgram {
/* The main method of the class.*/
public static void main(String[] args) {
//display string
System.out.println(First Java program.");
}
}
28

Literals
A literal is a constant value of certain type.
It can be used anywhere values of this type are allowed.
Examples:
a)100
b)98.6
c)X
d)test
class MyProgram {
public static void main(String[] args) {
System.out.println(My first Java program.");
}
29
}

Literals
Literals express constant values.
The form of a literal depends on its type:
1) integer types
2) floating-point types
3) character type
4) boolean type
5) string type

30

Literals: Integer Types

Writing numbers with different bases:

1) decimal 123
2) octal 0173
3) hexadecimal 0x7B
Integer literals are of type int by default.
Integer literal written with L (e.g. 123L) are of type
long.

31

Literals: Floating-Point Types

Two notations:
1) standard 2000.5
2) scientific 2.0005E3
Floating-point literals are of type double by default.
Floating-point literal written with F
(e.g. 2.0005E3F) are of type float.

32

Literals: Boolean
Two literals are allowed only: true and false.
Those values do not convert to any numerical
representation.
In particular:
1) true is not equal to 1
2) false is not equal to 0

33

Literals: Characters
Character literals belong to the Unicode character set.
Representation:
1) visible characters inside quotes, e.g. a
2) invisible characters written with escape sequences:
a) \ddd octal character ddd
b) \uxxxx hexadecimal Unicode character xxxx
c) \
single quote
d) \ double quote
e) \\
backslash
f) \r
carriage return
g) \n
new line
h) \f
form feed
i) \t
tab
j) \b
backspace
34

Literals: String
String is not a simple type.
String literals are character-sequences enclosed in double
quotes.
Example:
Hello World!
Notes:
1) escape sequences can be used inside string literals
2) string literals must begin and end on the same line
3) unlike in C/C++, in Java String is not an array of
characters
35

Separators
()

parenthesis

{}

braces

[]

Brackets

semicolon

comma

period

lists of parameters in method definitions and invocations,

Precedence in expressions, type casts
block of code, class definitions, method definitions, local
scope, automatically initialized arrays
declaring array types, referring to array values
terminating statements, chain statements inside the for
statement
separating multiple identifiers in a variable declaration
separate package names from subpackages and classes,
separating an object variable from its attribute or method
36

Keywords
Keywords are reserved words recognized by Java that cannot
be used as identifiers. Java defines 49 keywords as follows:

37

Operators Types
Java operators are used to build value expressions.
Java provides a rich set of operators:
1) assignment
2) arithmetic
3) relational
4) logical
5) bitwise
6) other

38

Assignment Operator
A binary operator:
variable = expression;
It assigns the value of the expression to the variable.
The types of the variable and expression must be
compatible.
The value of the whole assignment expression is the
value of the expression on the right, so it is possible
to chain assignment expressions as follows:
int x, y, z;
x = y = z = 2;
39

Arithmetic Operators
Java supports various arithmetic operators for:
1) integer numbers
2) floating-point numbers
There are two kinds of arithmetic operators:
1) basic: addition, subtraction, multiplication,
division and modulo
2) shortcut: arithmetic assignment, increment and
decrement

40

Table: Basic Arithmetic Operators

41

Arithmetic Assignment Operators

Instead of writing
variable = variable operator expression;
for any arithmetic binary operator, it is possible to
write shortly
variable operator= expression;
Benefits of the assignment operators:
1) save some typing
2) are implemented more efficiently by the Java
run-time system
42

Table: Arithmetic Assignments

43

Increment/Decrement Operators
Two unary operators:
1) ++ increments its operand by 1
2) -- decrements its operand by 1
The operand must be a numerical variable.
Each operation can appear in two versions:
prefix version evaluates the value of the operand after
performing the increment/decrement operation
postfix version evaluates the value of the operand
before performing the increment/decrement operation
44

Table: Increment/Decrement

45

Example: Increment/Decrement
class IncDec {
public static void main(String args[]) {
int a = 1; int b = 2; int c, d;
c = ++b;
d = a++;
c++;
System.out.println(a= + a);
System.out.println(b= + b);
System.out.println(c= + c);
}
}
46

Relational Operators
Relational operators determine the relationship that
one operand has to the other operand, specifically
equality and ordering.
The outcome is always a value of type boolean.
They are most often used in branching and loop
control statements.

47

Table: Relational Operators

48

Logical Operators
Logical operators act upon boolean operands only.
The outcome is always a value of type boolean.
In particular, 1 and 2 and 1 or 2 logical operators
occur in two forms:
1) full op1 & op2 and op1 | op2 where both op1 and
op2 are evaluated
2) short-circuit - op1 && op2 and op1 || op2 where
op2 is only evaluated if the value of op1 is
insufficient to determine the final outcome
49

Table: Logical Operators

50

Example: Logical Operators

class LogicalDemo {
public static void main(String[] args) {
int n = 2;
if (n != 0 && n / 0 > 10)
System.out.println("This is true");
else
System.out.println("This is false");
}
} Another example is needed
51

Strong Typing
Java is a strongly-typed language:
a) every variable and expression has a type
b) every type is strictly defined
c) all assignments are checked for type-compatibility
d) no automatic conversion of non-compatible,
conflicting types
e) Java compiler type-checks all expressions and
parameters
f) any typing errors must be corrected for compilation to
succeed
52

Simple Types
Java defines eight simple types:
1) byte 8-bit integer type
2) short 16-bit integer type
3) int 32-bit integer type
4) long 64-bit integer type
5) float 32-bit floating-point type
6) double 64-bit floating-point type
7) char symbols in a character set
8) boolean logical values true and false
53

Simple Type: byte

8-bit integer type.

Range: -128 to 127.
Example:
byte b = -15;
Usage: particularly when working with data streams.

54

Simple Type: short

16-bit integer type.

Range: -32768 to 32767.
Example:
short c = 1000;
Usage: probably the least used simple type.

55

Simple Type: int

32-bit integer type.
Range: -2147483648 to 2147483647.
Example:
int b = -50000;
Usage:
1) Most common integer type.
2) Typically used to control loops and to index
arrays.
3) Expressions involving the byte, short and int
values are promoted to int before calculation.
56

Simple Type: long

64-bit integer type.
Range: -9223372036854775808 to
9223372036854775807.
Example:
long l = 10000000000000000;
Usage:
1) useful when int type is not large enough to hold the
desired value

57

Simple Type: float

32-bit floating-point number.
Range: 1.4e-045 to 3.4e+038.
Example:
float f = 1.5;
Usage:
1) fractional part is needed
2) large degree of precision is not required

58

Simple Type: double

64-bit floating-point number.
Range: 4.9e-324 to 1.8e+308.
Example:
double pi = 3.1416;
Usage:
1) accuracy over many iterative calculations
2) manipulation of large-valued numbers

59

Example: double
// Compute the area of a circle.
class Area {
public static void main(String args[]) {
double pi = 3.1416; // approximate pi value
double r = 10.8; // radius of circle
double a = pi * r * r; // compute area
System.out.println("Area of circle is " + a);
}
} O/p =Area of circle is 366.436224
60

Simple Type: char

16-bit data type used to store characters.
Range: 0 to 65536.
Example:
char c = a;
Usage:
1) Represents both ASCII and Unicode character sets;
Unicode defines a character set with characters found
in (almost) all human languages.
2) Not the same as in C/C++ where char is 8-bit and
represents ASCII only.
61

Example: char
// Demonstrate char data type.
class CharDemo {
public static void main(String args[]) {
char ch1, ch2;
ch1 = 88; // code for X
ch2 = 'Y';
System.out.print("ch1 and ch2: ");
System.out.println(ch1 + " " + ch2);
}
}O/p ch1 and ch2 : X Y
62

Another Example: char

It is possible to operate on char values as if they were
integers:
class CharDemo2 {
public static void main(String args[]) {
char c = 'X';
System.out.println("c contains " + c);
c++; // increment c
System.out.println("c is now " + c);
}
}
63

Simple Type: boolean

Two-valued type of logical values.
Range: values true and false.
Example:
boolean b = (1<2);
Usage:
1) returned by relational operators, such as 1<2
2) required by branching expressions such as if or for

64

Example: boolean
class BoolTest {
public static void main(String args[]) {
boolean b;
b = false;
System.out.println("b is " + b);
b = true;
System.out.println("b is " + b);
if (b) System.out.println("executed");
b = false;
if (b) System.out.println(not executed");
System.out.println("10 > 9 is " + (10 > 9));
}
65
}

Variables
1) declaration how to assign a type to a variable
2) initialization how to give an initial value to a variable
3) scope how the variable is visible to other parts of the
program
4) lifetime how the variable is created, used and destroyed
5) type conversion how Java handles automatic type
conversion
6) type casting how the type of a variable can be narrowed
down
7) type promotion how the type of a variable can be
expanded
66

Basic Variable Declaration

form of variable declaration: Basic

67

Variable Declaration
We can declare several variables at the same time:
type identifier [=value][, identifier [=value] ]; ];
Examples:
int a, b, c;
int d = 3, e, f = 5;
byte hog = 22;
double pi = 3.14159;
char kat = 'x';

68

Constant Declaration
A variable can be declared as final:
final double PI = 3.14;
The value of the final variable cannot change after it
has been initialized:
PI = 3.13;

69

Variable Identifiers
Identifiers are assigned to variables, methods and classes.
An identifier:
1) starts with a letter, underscore _ or dollar $
2) can contain letters, digits, underscore or dollar characters
3) it can be of any length
4) it must not be a keyword (e.g. class)
5) it must be unique in its scope
Examples: identifier, userName, _sys_var1, $change
The code of Java programs is written in Unicode, rather than
ASCII, so letters and digits have considerably wider
definitions than just a-z and 0-9.
70

Naming Conventions
Conventions are not part of the language.
Naming conventions:
1) variable names begin with a lowercase letter
2) class names begin with an uppercase letter
3) constant names are all uppercase
If a variable name consists of more than one word,
the words are joined together, and each word after the
first begins with an uppercase letter.
The underscore character is used only to separate
words in constants, as they are all caps and thus
cannot be case-delimited.
71

Variable Initialization
During declaration, variables may be optionally
initialized.
Initialization can be static or dynamic:
1) static initialize with a literal:
int n = 1;
2) dynamic initialize with an expression composed of
any literals, variables or method calls available at the
time of initialization:
int m = n + 1;
The types of the expression and variable must be the
same.
72

Example: Variable Initialization

class DynamicInit {
public static void main(String args[]) {
double a = 3.0, b = 4.0;
double c = Math.sqrt(a * a + b * b);
System.out.println("Hypotenuse is " + c);
}
}

73

Variable Scope
Scope determines the visibility of program elements
with respect to other program elements.
In Java, scope is defined separately for classes and
methods:
1) variables defined by a class have a global scope
2) variables defined by a method have a local scope
We consider the scope of method variables only; class
variables will be considered later.
74

Variable Scope

75

Scope Definition
A scope is defined by a block:
{

}
A variable declared inside the scope is not visible
outside:
{
int n;
}
n = 1;
76

Example: Variable Scope

class Scope {
public static void main(String args[]) {
int x;
x = 10;
if (x == 10) {
int y = 20;
System.out.println("x and y: " + x + " + y);
x = y * 2;
}
System.out.println("x is " + x + y is + y);
}
}
77

Variable Lifetime
Variables are created when their scope is entered by
control flow and destroyed when their scope is left:
1) A variable declared in a method will not hold its
value between different invocations of this method.
2) A variable declared in a block looses its value when
the block is left.
3) Initialized in a block, a variable will be re-initialized
with every re-entry.
Variable3s lifetime is confined to its scope!
78

Example: Variable Lifetime

classLifeTime{
publicstaticvoidmain(Stringargs[]){
intx;
for(x=0;x<3;x++){
inty=1;
System.out.println("yis:"+y);
y=100;
System.out.println("yisnow:"+y);
}
}
}
79

Type Differences
Suppose a value of one type is assigned to a variable
of another type.
T1 t1;
T2 t2 = t1;
What happens? Different situations:
1) types T1 and T2 are incompatible
2) types T1 and T2 are compatible:
a) T1 and T2 are the same
b) T1 is larger than T2
c) T2 is larger than T1
80

Type Compatibility
When types are compatible:
1) integer types and floating-point types are compatible
with each other
2) numeric types are not compatible with char or boolean
3) char and boolean are not compatible with each other
Examples:
byte b;
int i = b;
char c = b;
81

Widening Type Conversion

Java performs automatic type conversion when:
1) two types are compatible
2) destination type is larger then the source type
Example:
int i;
double d = i;

82

Narrowing Type Conversion

When:
1) two types are compatible
2) destination type is smaller then the source type then
Java will not carry out type-conversion:
int i;
byte b = i;
Instead, we have to rely on manual type-casting:
int i;
byte b = (byte)i;
83

Type Promotion Rules

1) byte and short are always promoted to int
2)if one operand is long , the whole expression is
promoted to long
3) if one operand is float ,the entire expression is
promoted to float
4)if any operand is double , the result is double
Danger of automatic type promotion:
byte b = 50;
b = b * 2;
What is the problem?
84

Example: Type Promotion

class Promote {
public static void main(String args[]) {
byte b = 42;
char c = 'a';
short s = 1024;
int i = 50000;
float f = 5.67f;
double d = .1234;
double result = (f * b) + (i / c) - (d * s);
System.out.println("result = " + result);
}
}

85

Control Flow
Java control statements cause the flow of execution to
advance and branch based on the changes to the state
of the program.
Control statements are divided into three groups:
1. selection statements allow the program to choose
different parts of the execution based on the
outcome of an expression
2. Iteration statements enable program execution to
repeat one or more statements.
3. Jump statements enable your program to execute in
a non-linear fashion
86

Selection Statements
Java selection statements allow to control the
flow of programs execution based upon
conditions known only during run-time.
Java provides four selection statements:
1.
2.
3.
4.

if
if-else
if-else-if
switch
87

if Statement
General form:
if (expression) statement;
If expression evaluates to true, execute
statement, otherwise do nothing.
The expression must be of type boolean.

88

Simple/Compound Statement
The component statement may be:
1) simple
if (expression) statement;
2) compound
if (expression) {
statement;
}
89

Simple/Compound Statement

90

Simple if Statement
Example:
class IfStat{
public static void main(String args[]) {
boolean b;
b = true;
System.out.println("b is " + b);
if (b) System.out.println("executed");
b = false;
if (b) System.out.println("not executed");
}
}
91

Compound if Statement
Example:
class IfState1{
public static void main(String args[]) {
int a=10;
if ( a>0) {
System.out.println( a is +ve num");
}
}
}
92

if-else Statement
If the conditional expression is true, the target
of the if will be executed;
otherwise, if it exists,the target of the else will
be executed.
At no time will both of them be executed.
The conditional expression controlling the if
must produce a boolean result.

93

if-else Statement
Syntax:
if(conditional_expression){
<statements>;
...;
...;
}
else{
<statements>;
....;
....;
}

94

if-else Statement

95

if else Statement
Example:
class IfElse{
public static void main(String args[]) {
int a=10;
if ( a>0) {
System.out.println( a is +ve num");
}
else{
System.out.println( a is - ve num");
}
}
96
}

Nested if Statement
A nested if is an if statement that is the target
of another if or else.
Nested ifs are very common in programming.
When you nest ifs, the main thing to remember
is that an else statement always refers to the
nearest if statement that is within the same
block as the else and that is not already
associated with an else.
97

Nested if Statement
class Example4_2{
public static void main(String Args[]){
int a = 3;
if (a <= 10 && a > 0){
System.out.println("Number is valid.");
if ( a < 5)
System.out.println("From 1 to 5");
else
System.out.println("From 5 to 10");
}
else
System.out.println("Number is not valid");
}
98
}

else-if ladder Statement

A common programming construct that is based upon the
nested if is the if-else-if ladder.
It looks like this:
if(condition)
statement;
else if(condition)
statement;
else if(condition)
statement;
...
else
statement;
99

else-if ladder Statement

100

else-if ladder Statement

Semantics:
1. statements are executed top-down
2. As soon as a true condition is found, the statement
associated with it is executed, and the rest of the ladder
is bypassed.
3. If none of the conditions is true, the final else statement
will be executed.
. The final else often acts as a default condition; that is, if
all other conditional tests fail, the last else statement is
performed.

101

else-if ladder Statement

class Ladder {
public static void main(String args[]) {
int x;
x = Integer.parseInt(args[]);
if(x==1) System.out.println("x is one");
else if(x==2) System.out.println("x is two");
else if(x==3) System.out.println("x is three");
else if(x==4) System.out.println("x is four");
else
System.out.println("x is not between 1 and 4");
}
}
102

switch Statement
switch provides a better alternative than if-else-if
when the execution follows several branches
depending on the value of an expression.
The switch provides for a multiway branch. Thus,
it enables a program to select among several
alternatives.
the value of an expression is successively tested
against a list of constants.
When a match is found, the statement sequence
associated with that match is executed.
103

switch Statement
The general form of the switch statement is
switch (expression) {
case constant1:
statement sequence
break;
case constant2:
statement sequence
break;
case constant3:
statement sequence
break;
...
default:
statement sequence
}

104

switch Statement

105

switch Statement
Assumptions:
1. expression must be of type byte, short, int or char
2. each of the case values must be a literal of the compatible
type
3. case values must be unique
Semantics:
4. expression is evaluated
5. its value is compared with each of the case values
6. if a match is found, the statement following the case is
executed
7. if no match is found, the statement following default is
executed
. break makes sure that only the matching statement is executed.
. Both default and break are optional.
106

switch Statement
class SwitchDemo {
public static void main(String args[]) {
int i;
i = Integer.parseInt(args[0]);
switch(i) {
case 0: System.out.println("i is zero"); break;
case 1: System.out.println("i is one"); break;
case 2: System.out.println("i is two") ;break;
case 3: System.out.println("i is three"); break;
case 4: System.out.println("i is four"); break;
default: System.out.println("i is five or more");
}
}
}
107

For Loop
For loop executes group of Java statements as
long as the boolean condition evaluates to true.
For loop combines three elements which we
generally use: initialization statement, boolean
expression and increment or decrement
statement.

108

For Loop
For loop syntax
for( <initialization> ; <condition> ; <statement> )
{
.
<Block of statements>;
.
}
109

For Loop

110

For Loop
The initialization statement is executed before the
loop starts.
It is generally used to initialize the loop variable.
Condition statement is evaluated before each time the
block of statements are executed.
Block of statements are executed only if the boolean
condition evaluates to true.
Statement is executed after the loop body is done.
Generally it is being used to increment or decrement
the loop variable.
111

For Loop
Following example shows use of simple for loop.
for(int i=0 ; i < 5 ; i++)
{
System.out.println(i is : + i);
}
It is possible to initialize multiple variable in the
initialization block of the for loop by separating it by
comma as given in the below example.
For(i=0,j=5;i<5;i++)
It is also possible to have more than one increment or
decrement section as well as given below.
112
for(int i=0; i < 5 ; i++, j--)

The while Loop

The general form of the while loop is

while(condition) {
statement;
}
The condition can be any Boolean expression.
The body of the loop will be executed as long
as the conditional expression is true.
When condition becomes false, control passes
to the next line of code immediately following
the loop.
The curly braces are unnecessary if only a
single statement is being repeated.
113

The while Loop

114

The while Loop

class While {
public static void main(String args[]) {
int n = 10;
while(n > 0) {
System.out.println("tick " + n);
n--;
}
}
}
115

do-while Loop
general form is
do {
// body of loop
} while (condition);
Each iteration of the do-while loop first executes
the body of the loop and then evaluates the
conditional expression.
If this expression is true, the loop will repeat.
Otherwise, the loop terminates. As with all of
Javas loops, condition must be a Boolean
expression.
116

do-while Loop

117

do-while Loop
The do-while loop always executes its body at least
once, because its conditional expression is at the
bottom of the loop.
class DoWhile {
public static void main(String args[]) {
int n = 10;
do {
System.out.println("tick " + n);
n--;
} while(n > 0);
}
118
}

Jump Statements
Java jump statements enable transfer of control to
other parts of program.
Java provides three jump statements:
1) break
2) continue
3) return
In addition, Java supports exception handling that
can also alter the control flow of a program.
119

1. break Statement
The break statement has three uses:
1) to terminate a case inside the switch
statement
2) to exit an iterative statement
3) to transfer control to another statement
(1) has been described.
We continue with (2) and (3).
120

Using break to Exit a Loop

By using break, there will an immediate
termination of a loop, bypassing the
conditional expression and any remaining code
in the body of the loop.
When a break statement is encountered inside
a loop, the loop is terminated and program
control resumes at the next statement
following the loop.
121

Loop Exit with break

When break is used inside a loop, the loop terminates
and control is transferred to the following instruction.
class BreakLoop {
public static void main(String args[]) {
for (int i=0; i<100; i++) {
if (i == 10) break;
System.out.println("i: " + i);
}
System.out.println("Loop complete.");
}
}
122

break in Nested Loops

Used inside nested loops, break will only terminate the innermost
loop:
class NestedLoopBreak {
public static void main(String args[]) {
for (int i=0; i<3; i++) {
System.out.print("Pass " + i + ": ");
for (int j=0; j<100; j++) {
if (j == 10) break; System.out.print(j + " ");
}
System.out.println();
}
System.out.println("Loops complete.");
}
123
}

Control Transfer with break

Java does not have an unrestricted goto statement,
which tends to produce code that is hard to
understand and maintain.
However, in some places, the use of gotos is well
justified. In particular, when breaking out from the
deeply nested blocks of code.
break occurs in two versions:
1) unlabelled
2) labeled
The labeled break statement is a civilized
replacement for goto.
124

Labeled break
General form:
break label;
where label is the name of a label that
identifies a block of code:
label: { }
The effect of executing break label; is to
transfer control immediately after the block of
code identified by label.
125

Example: Labeled break

class Break {
public static void main(String args[]) {
boolean t = true;
first: {
second: {
third: {
System.out.println("Before the break.");
if (t) break second;
System.out.println("This won't execute");
}
System.out.println("This won't execute");
}
System.out.println(After second block.");
}
}
126
}

Example: Nested Loop break

class NestedLoopBreak {
public static void main(String args[]) {
outer: for (int i=0; i<3; i++) {
System.out.print("Pass " + i + ": ");
for (int j=0; j<100; j++) {
if (j == 10) break outer; // exit both loops
System.out.print(j + " ");
}
System.out.println("This will not print");
}
System.out.println("Loops complete.");
}
}

127

break Without Label

It is not possible to break to any label which is not defined
for an enclosing block.
Trying to do so will result in a compiler error.
class BreakError {
public static void main(String args[]) {
one: for(int i=0; i<3; i++) {
System.out.print("Pass " + i + ": ");
}
for (int j=0; j<100; j++) {
if (j == 10) break one;
System.out.print(j + " ");
}
}
128
}

continue Statement
The break statement terminates the block of code, in
particular it terminates the execution of an iterative
statement.
The continue statement forces the early termination of
the current iteration to begin immediately the next
iteration.
Like break, continue has two versions:
1) unlabelled continue with the next iteration of the
current loop
2) labeled specifies which enclosing loop to
continue
129

Example: Unlabeled continue

class Continue {
public static void main(String args[]) {
for (int i=0; i<10; i++) {
System.out.print(i + " ");
if (i%2 == 0) continue;
System.out.println("");
}
}
}
130

Example: Labeled continue

class LabeledContinue {
public static void main(String args[]) {
outer: for (int i=0; i<10; i++) {
for (int j=0; j<10; j++) {
if (j > i) {
System.out.println();
continue outer;
}
System.out.print(" " + (i * j));
}
}

System.out.println();
}

131

Return Statement
The return statement is used to return from the
current method: it causes program control to transfer
back to the caller of the method.
Two forms:
1) return without value
return;
2) return with value
return expression;

132

Example: Return
class Return {
public static void main(String args[]) {
boolean t = true;
System.out.println("Before the return.");
if (t) return; // return to caller
System.out.println("This won't execute.");

}
}

133

Arrays
An array is a group of liked-typed variables referred
to by a common name, with individual variables
accessed by their index.
Arrays are:
1) declared
2) created
3) initialized
4) used
Also, arrays can have one or several dimensions

134

Array Declaration
Array declaration involves:
1) declaring an array identifier
2) declaring the number of dimensions
3) declaring the data type of the array elements
Two styles of array declaration:
type array-variable[];
or
type [] array-variable;

135

Array Creation
After declaration, no array actually exists.
In order to create an array, we use the new operator:
type array-variable[];
array-variable = new type[size];
This creates a new array to hold size elements of type,
which reference will be kept in the variable arrayvariable.

136

Array Indexing
Later we can refer to the elements of this array
through their indexes:
array-variable[index]
The array index always starts with zero!
The Java run-time system makes sure that all array
indexes are in the correct range, otherwise raises a
run-time error.

137

Example: Array Use

class Array {
public static void main(String args[]) {
int monthDays[];
monthDays = new int[12];
monthDays[0] = 31;
monthDays[1] = 28;
monthDays[2] = 31;
monthDays[3] = 30;
monthDays[4] = 31;
monthDays[5] = 30;

monthDays[12] = 31;
System.out.print(April has );
System.out.println(monthDays[3] + days.);
}
}

138

Array Initialization
Arrays can be initialized when they are declared:
int monthDays[] = {31,28,31,30,31,30,31,31,30,31,30,31};
Comments:
1) there is no need to use the new operator
2) the array is created large enough to hold all specified elements

139

Example: Array Initialization

class Array {
public static void main(String args[]) {
int mthDys[]= {31,28,31,30,31,30,31,31,30,31,30,31};
System.out.print(April );
System.out.println(mthDys[3]+ days.);
}
}

140

Multidimensional Arrays
Multidimensional arrays are arrays of arrays:
1) declaration
int array[][];
2) creation
int array = new int[2][3];
3) initialization
int array[][] = { {1, 2, 3}, {4, 5, 6} };

141

Example: Multidimensional Arrays

class Array {
public static void main(String args[]) {
int array[][] = { {1, 2, 3}, {4, 5, 6} };
int i, j, k = 0;
for(i=0; i<2; i++) {
for(j=0; j<3; j++)
System.out.print(array[i][j] + " ");
System.out.println();
}
}
}
142