OOPR MIDTERMS REPETITION CONTROL STRUCTURES

Module 5: Java Control - Allow to execute specific sections of

the code a number of times.
Statements – CONDITIONAL
STATEMENTS
Understanding IF Statements
JAVA STATEMENT
THE IF STATEMENT
- In Java, a STATEMENT is one or more
lines of code ending with a semi- - The IF STATEMENT executes a block
colon (;). of code only if the specified
- It generally contains expressions expression is true.
(expressions have a value).

SIMPLE STATEMENT
- Basic building blocks of a program.
- One or more lines terminated by a
semicolon (;).

COMPOUND STATEMENT OR BLOCK

- Used to organize simple statements
into complex structures.
- One or more statements enclose by
braces { } .
EVERY TIME JAVA ENCOUNTERS AN IF
- Recommended to indent blocks for STATEMENT,
readability.
1. It determines whether EXPRESSION is
TRUE or FALSE.
2. If EXPRESSION IS TRUE, then Java
EXECUTES STATEMENT.

CONTROL STRUCTURE 3. If EXPRESSION IS FALSE, then Java

- Control structures allow to change
the ordering of how the statements
in a program is executed.
- Java statements that allows a
programmer to select and execute
SPECIFIC BLOCKS OF CODE while
skipping other sections
IGNORES or SKIPS the remainder of
the IF statement and proceeds to
the next statement.
Making a decision involves choosing
between two alternative courses of action
based on some value within a program.

INCLUDE TYPES SUCH AS:

- If
- If-Else
- If-Else-If
- Switch structure
TYPES OF CONTROL STRUCTURES:

DECISION CONTROL STRUCTURES

- Allow to select specific sections of
code to be executed.
IF STRUCTURE: EXAMPLE 1 IF- ELSE STRUCTURE: EXAMPLE 1
- Suppose that the passing grade on
an examination is 75 (out of 100).
Then the if statement may be written
in Java as:

IF- ELSE STRUCTURE: EXAMPLE 2

IF STRUCTURE : EXAMPLE 2

Complex Conditionals
IF- ELSE STRUCTURE: EXAMPLE 3
THE IF-ELSE STATEMENT
- The IF/ELSE STATEMENT is an extension
of the if statement. If the statements
in the if statement fails, the
statements in the else bock are
executed.

NESTED IF STATEMENT

- A NESTED IF is an if statement that is

Making a decision involves choosing
between two alternative courses of action
based on some value within a program.
the target of another if or else.
Nested if statements means an if
statement inside an if statement. Yes,
java allows us to nest if statements
within if statements. i.e, we can
place an if statement inside another
if statement.
The Switch, Case, and Break
Statements

SWITCH CASE STATEMENT

- Also called a case statement is a
multi-way branch with several
choices.
- A switch is easier to implement than
a series of if/else statements.

Module 6: Java Control

Statements LOOPING
STATEMENTS

LOOP STATEMENT
- Allows us to execute a statement or
group of statements multiple times
and following is the general form of
a loop statement in most of the
programming languages.

BREAK STATEMENT
- Defines the end of a case.
DEFAULT STATEMENT
- Use in defining message to be
displayed that is outside of the given
case.

THREE (3) CATEGORIES OF LOOP

STATEMENTS

FOR LOOP – executes a sequence of

statements multiple times and
abbreviates the code that manages
the loop variable.

WHILE LOOP – repeats a statement or

group of statements while a given
condition is true. It tests the condition
before executing the loop body.

DO… WHILE LOOP – like a while

statement, except that it tests the
condition at the end of the loop body.
Understanding FOR LOOP Understanding WHILE LOOP

FOR LOOP WHILE LOOP

- It is useful when you know how many - A WHILE LOOP STATEMENT in Java
times a task is to be repeated. Programming Language repeatedly
- A repetition control structure that executes a target statement as long
allows you to efficiently write a loop as a given condition is true.
that needs to be executed a
WHILE LOOP Statement
specific number of times.

FOR LOOP STATEMENT

WHILE

- Here, key point of the WHILE LOOP is

FOR LOOP DEMO that the loop might not ever run.
When the expression is tested and
the result is false, the loop body will
be skipped and the first statement
after the while loop will be executed.

WHILE LOOP DEMO

Understanding DO…WHILE LOOP Module 7: Exception Handling

EXCEPTION
DO… WHILE LOOP
- An EXCEPTION is an event, usually
- A DO…WHILE LOOP is similar to a some form of error, which happens
while loop, except that a DO…WHILE during the normal course of program
LOOP is guaranteed to execute at execution. The object-oriented
least one time. technique to manage such errors
comprises the group of methods
DO… WHILE LOOP STATEMENT known as exception handling.

Exception Hierarchy

TYPES OF EXCEPTIONS

ERROR – serious errors in the java runtime

system.

EXCEPTION / CHECKED – The classes which

directly inherit throwable class except run
DO… WHILE LOOP DEMO time exception and error are known as
checked exceptions normal errors that can
occur during the execution of a program.

RUN TIME EXCEPTION / UNCHECKED –

encompasses all exceptions which can
ordinarily happen at runtime.
COMMON EXCEPTIONS
ARITHMETIC EXCEPTION – caused by math
errors such as division by zero.
ARRAY INDEX OUT OF BOUNDS EXCEPTION
– caused by a bad array index.
ARRAY STORE EXCEPTION – caused when
a program tries to store the wrong type of
data in an array.
FILE NOT FOUND EXCEPTION – caused by
an attempt to access a nonexistent file.
I O EXCEPTION – caused by general I / O
failures, such as inability to read from a file.
NULL POINTER EXCEPTION – caused by
referencing a null object.
NUMBER FORMAT EXCEPTION – caused
when a conversation between string and
number fails.
OUT OF MEMORY EXCEPTION – caused
when there is not enough memory to
allocate a new object.
SECURITY EXCEPTION – caused by a
security violation such as when an applet
tries to perform an action not allowed by
the browser’s security setting.
STACK OVER FLOW EXCEPTION – caused
when a program attempts to access a
nonexistent character position in a string.
Creating Exception
GENERATING EXCEPTIONS
METHOD CALLS – If a method or
constructor is declared to throw an
exception, then calling that method or
constructor may result in an exception of
the declared class or a subclass.
RUNTIME EXCEPTIONS – these exceptions
can occur even though the offending
piece of code does not declare that it
throws such an exception.
EXAMPLES OF THESE EXCEPTIONS INCLUDE:
USER EXCEPTIONS – these are exceptions
that are manually thrown by the
programmer using the throw statement.
- This statement takes a single
argument which must be an object
that is a subclass of Throwable. You
can either throw an existing
exception class or create your own.
- throw new Exception (“Problem”);
Try, Catch, and Finally
HANDLING EXCEPTION
PASSING ON EXCEPTIONS
- Passing on an exception refers to
letting the method’s caller catch the
exception. When a method declares
that it can throw an exception of a
particular type. Within the method
body, it can perform actions which
may cause that type of exception to
be thrown.
CATCHING EXCEPTIONS
- Catching an exception refers to
declaring that you can handle
exceptions of a particular class from
a particular block of code.
- You specify the block of code and
then provide handlers for various
classes of exception. If an exception
occurs then execution transfers to
the corresponding piece of handler
code.
THE TRY BLOCK
- When you create a segment of
code in which something might go
wrong, you place the code in a try
block, which is a block of code you
attempt to execute while
acknowledging that an exception
might occur.
A TRY BLOCK CONSISTS OF THE FOLLOWING
FORMAT:
Catch and finally blocks…
THE CATCH BLOCK
- A catch block is a segment of code
that can handle an exception that
might be thrown by the try block
that precedes it.
A CATCH BLOCK HAS THE FOLLOWING FORMAT:
SYNTAX KEY ASPECTS
- The block notation is mandatory.
- A try block must be followed by at
least one catch block or one.
- For each try block, there can be one
or more catch blocks, but at most
only one finally block.
- Finally block.
- The catch blocks and finally blocks
must always appear in conjunction
with the try block, and in the above
order.
- Each catch block defines an
exception handle. The header of the
catch block takes exactly one
argument, which is the exception it
will handle. The exception must be of
the throwable class or one of its
subclasses.

THROWS CLAUSE

- A throws clause lists the types of

exceptions that a method might
Finally blocks… throw. This is necessary for all
exceptions, except those of type
Error and Runtime Exception, or any
TRY CATCH DEMO 1 of their subclasses.
- All other exceptions that a method
can throw must be declared in the
throws clause. If they are not, a
compile-time error will occur.

THROWS CLAUSE EXAMPLE 1:

TRY CATCH DEMO 2

THROWS CLAUSE EXAMPLE 2:

ILLUSTRATING MORE THAN ONE EXCEPTION.
ASSERTION IN JAVA
HANDLING
- An assertion allows testing the
correctness of any assumptions that
have been made in the program.
- Assertion is achieved using the assert
statement in Java. While executing
assertion, it is believed to be true. If it
fails, JVM throws an error named
AssertionError. It is mainly used for
testing purposes during
development.
WHERE TO USE ASSERTIONS
- The assert statement is used with a
Boolean expression and can be
written in two different ways.
SYNTAX:
ASSERTION VS NORMAL EXCEPTION
- Assertions are mainly used to check
logically impossible situations. For
example, they can be used to
check the state a code expects
before it starts running or state after it
finishes running. Unlike normal
exception/error handling, assertions
are generally disabled at run-time.
- Arguments to private methods.
Private arguments are provided by
developer’s code only and
developer may want to check
his/her assumptions about
arguments.
- Conditional cases
- Conditions at the beginning of any
method.

WHERE NOT TO USE ASSERTIONS

- Assertions should not be used to

replace error messages.
- Assertions should not be used to
check arguments in the public
methods as they may be provided
by user. Error handling should be
used to handle errors provided by
user.
- Assertions should not be used on
WHY USE ASSERTIONS? command line arguments.

- To make sure that an unreachable

looking code is actually
unreachable.
- To make sure that assumptions
written in comments are right. if ((x &
1) == 1) { } else // x must be even {
assert (x % 2 == 0); }
- To make sure default switch case is
not reached.
- To check object’s state.
- In the beginning of the method
- After method invocation.