Interactive Programming In Java

Introduction to Interactive Programming
by Lynn Andrea Stein
A Rethinking CS101 Project

Java Charts

Statement

Java statements are executable code with neither type nor value. A Java statement is made up of exactly one of the following (though its pieces sometimes contain other statements).

;

This is an empty statement. Executing it has no effect. Execution continues immediately after this statement.

expression;

This is a simple statement. expression must be a side-effecting expression, i.e., an assignment, autoincrement, autodecrement, method invocation, or new expression.

This kind of statement simply evaluates the expression and terminates. Execution continues immediately after this statement.

{statements}

This is a block. statements is simply a sequence of zero or more statements, one after the other.

This kind of statement executes by executing each statement in statements, in order. After it completes, execution continues immediately after the closing brace.

type name ;⁶

This is a simple declaration.

A declaration statement is executed by creating an association between the name name and the type type for the remainder of the execution of the enclosing block. Execution continues immediately after this statement.

type name= value;⁶

This is a definition -- a declaration coupled with an intialization assigment.

The execution of a definition is identical to the execution of a declaration except that the value associated with name is initially set to be value.

returnoptionalExpression ;

Executing a return statement has the effect of exiting the innermost enclosing method. If optionalExpression is present, it is evaluated and its value is returned by the method invocation.

synchronized (objExpression)block

A synchronized statement executes block. However, execution cannot begin until the exclusive lock on the object whose value is objExpression is held by the Thread executing the synchronized statement.

if (booleanExpression)statement

This is a simple conditional statement. booleanExpression is an expression whose type is boolean. statement is any statement, often a block.

A conditional statement is executed by first evaluating booleanExpression. If its value is true, statement is executed. If the value of booleanExpression is false, statement is not executed. In either case, execution continues immediately after this statement.

if (booleanExpression)statementelseanotherStatement

This is another form of conditional statement. booleanExpression is an expression whose type is boolean. Both statement and anotherStatement are arbitrary statements. Often statement is a block and anotherStatement is another conditional statement

A conditional statement is executed by first evaluating booleanExpression. There are two possibilities

1. If the value of booleanExpression is true, statement is executed, then execution continues after anotherStatement.

2. If booleanExpression. is false, execution skips statementand continues at anotherStatement.

switch (integralExpression) { caseintegralValue : default :statement}

A switch statement is a limited contditional. integralExpression is an expression with integral type (i.e., byte, short, int, long, boolean, or char). Each integralValues is a constant expression of the same integral type. Any number of caseintegralValue : and statement lines, and at most one default:, can be intermixed in any order in the switch body.

A switch statement evaluates integralExpression and compares its valuewith the various integralValues. When the first matching integralValue is encountered, the remainder of the statements in the switch body are executed. A default: matches any value. Frequently, a break statement is used to exit the switch body.

Typically, the format will be one or more case lines followed by one or more statements, often terminating in a break statement. This structure will then repeat. The final set of statements will often be preceded by default:

while (booleanExpression)statement

This is a while loop. booleanExpression is an expression whose type is boolean. statement is any statement, frequently a block.

A while loop is executed by first evaluating booleanExpression. If its value is false, execution continues after the while statement. Otherwise, statement is executed and then the while loop is executed again from the beginning.

dostatementwhile (booleanExpression )

This is a do loop. statement is any statement, frequently a block. booleanExpression is an expression whose type is boolean.

A do loop is executed by first executing statement. Next, booleanExpression. is evaluated. If its value is false, execution continues after the do loop. Otherwise the do loop is executed again from the beginning.

for (initExprs;booleanExpr;updateExprs)statement

This is a for loop. initExprs is a comma-separated sequence of expressions, typically one or more definitions or other initializations. booleanExpr is a single expression of type boolean. updateExprs is a comma-separated sequence of expressions, typically assignments or other updates.

To execute a for loop, first evaluate initExprs. These expressions are evaluated only once, at the beginning of the for loop.

Now evaluate booleanExpr. If its value is false, the for loop is complete; execution resumes after the entire statement. Otherwise, execute statement. Next, evaluate updateExprs. Regardless of its value, return to the beginning of this paragraph (evaluate booleanExprs).

label:statement

This is a labeled statement. label may be any Java identifier. It does not interfere with variable scoping, etc. statementmay be any statement, but is often a block or block-containing statement.

A labeled statement is executed exactly as though label were not present, except that the position within the code of the identifier labelis recorded. In particular, any break or continue statements appearing inside statement may make reference to label. (See break and continue statements in this chart.)

breakoptionalLabel ;

If optionalLabel is present, this is a labeled break statement; if it is absent, this is an unlabeled break statement.

A labeled break statement exits all enclosing blocks until one whose label matches optionalLabel is found. Execution resumes after that block.

An unlabeled break statement exits the innermost switch, while, do, or for statement containing that break. Execution resumes after that block.

continueoptionalLabel ;

The syntax of a continue statement is identical to that of a break statement. A continue statement may only appear inside a while, do, or for loop.

An unlabeled continue statement exits the current iteration of the innermost loop containing that continue statement. Execution resumes at the expression evaluation (test) of while and do loops, and at the update expression of a for loop.

A labeled continue statement exits the current iteration of the enclosing loop whose label matches optionalLabel. Execution resumes at the expression evaluation (test) of while and do loops, and at the update expression of a for loop.

throwexpression ;

Executing a throw statement has the effect of exiting every enclosing statement (including those containing method invocations) until a try statement with a catch clause matching the thrown object (the value of expression) is encountered. Execution resumes at this catch clause.

try tryBlockcatch (type name) catchBlockfinally finallyBlock

This is a try statement. tryBlock, catchBlock, and finallyBlock are each arbitrary blocks of statements. type is any type that implements Throwable; name is any Java name. The lines finally finallyBlock are optional and may be omitted entirely. The lines catch (type name )catchBlock form a catch clause. Each try statement may have zero or more catch clauses (but exactly one try and at most one finally).

To execute a try statement, tryBlockis executed. There are three possibilities:

1. If the execution of tryBlock completes normally, then execution continues at finallyBlock (if present).

2. If a throw statement is encountered during the execution of tryBlock and the type of the thrown object matches thetypeof one of the catch clauses, execution exitstryBlock and continues in the catchBlock of the first catch clause whose type matches the type of the thrown object. During execution of catchBlock, name is bound to the thrown object. After completing this catchBlock, execution continues at finallyBlock (if present).

3. If execution of tryBlock is interrupted for any other reason -- a thrown object that doesn't match a catch clause, a break or continue statement -- execution exitstryBlock and continues at finallyBlock (if present). If execution of finallyBlock completes normally (or if finallyBlock is absent, execution continues abnormally, i.e., as though finallyBlock had thrown the object or raised the break or continue. That is, execution continues exiting blocks until the throw, break, or continue is resolved.

This chapter is excerpted from a draft ofIntroduction to Interactive Programming In Java, a forthcoming textbook from Morgan Kaufmann Publishers, Inc. It is a part of the course materials developed as a part of Lynn Andrea Stein's Rethinking CS101 project at the MIT AI Lab and the Department of Electrical Engineering and Computer Science at the Massachusetts Institute of Technology.

Questions or comments:
<cs101-webmaster@ai.mit.edu>

Last modified: Tue Oct 6 13:39:55 1998

`;`	This is an empty statement. Executing it has no effect. Execution continues immediately after this statement.
`expression``;`	This is a simple statement. `expression` must be a side-effecting expression, i.e., an assignment, autoincrement, autodecrement, method invocation, or `new` expression. This kind of statement simply evaluates the expression and terminates. Execution continues immediately after this statement.
`{``statements``}`	This is a block. `statements` is simply a sequence of zero or more statements, one after the other. This kind of statement executes by executing each statement in `statements`, in order. After it completes, execution continues immediately after the closing brace.
`type name` `;`⁶	This is a simple declaration. A declaration statement is executed by creating an association between the name `name` and the type `type` for the remainder of the execution of the enclosing block. Execution continues immediately after this statement.
`type name``=` `value``;`⁶	This is a definition -- a declaration coupled with an intialization assigment. The execution of a definition is identical to the execution of a declaration except that the value associated with `name` is initially set to be `value`.
`return``optionalExpression` `;`	Executing a `return` statement has the effect of exiting the innermost enclosing method. If `optionalExpression` is present, it is evaluated and its value is returned by the method invocation.
`synchronized (``objExpression``)``block`	A `synchronized` statement executes `block`. However, execution cannot begin until the exclusive lock on the object whose value is `objExpression` is held by the Thread executing the `synchronized` statement.
`if (``booleanExpression``)``statement`	This is a simple conditional statement. `booleanExpression` is an expression whose type is boolean. `statement` is any statement, often a block. A conditional statement is executed by first evaluating `booleanExpression`. If its value is `true`, `statement` is executed. If the value of `booleanExpression` is `false`, `statement` is not executed. In either case, execution continues immediately after this statement.
`if (``booleanExpression``)``statement``else``anotherStatement`	This is another form of conditional statement. `booleanExpression` is an expression whose type is boolean. Both `statement` and `anotherStatement` are arbitrary statements. Often `statement` is a block and `anotherStatement` is another conditional statement A conditional statement is executed by first evaluating `booleanExpression`. There are two possibilities 1. If the value of `booleanExpression` is `true`, `statement` is executed, then execution continues after `anotherStatement`. 2. If `booleanExpression`. is `false`, execution skips `statement`and continues at `anotherStatement`.
`switch (``integralExpression``) { case``integralValue` `: default :``statement``}`	A `switch` statement is a limited contditional. `integralExpression` is an expression with integral type (i.e., `byte`, `short`, `int`, `long`, *`boolean,`* or `char`). Each `integralValue`s is a constant expression of the same integral type. Any number of `case``integralValue` : and `statement` lines, and at most one `default:`, can be intermixed in any order in the `switch` body. A `switch` statement evaluates `integralExpression` and compares its valuewith the various `integralValue`s. When the first matching `integralValue` is encountered, the remainder of the statements in the `switch` body are executed. A `default:` matches any value. Frequently, a `break` statement is used to exit the `switch` body. Typically, the format will be one or more `case` lines followed by one or more statements, often terminating in a `break` statement. This structure will then repeat. The final set of statements will often be preceded by `default:`
`while (``booleanExpression``)``statement`	This is a `while` loop. `booleanExpression` is an expression whose type is boolean. `statement` is any statement, frequently a block. A `while` loop is executed by first evaluating `booleanExpression`. If its value is `false`, execution continues after the `while` statement. Otherwise, `statement` is executed and then the `while` loop is executed again from the beginning.
`do``statement``while (``booleanExpression` `)`	This is a do loop. `statement` is any statement, frequently a block. `booleanExpression` is an expression whose type is boolean. A `do` loop is executed by first executing `statement`. Next, `booleanExpression`. is evaluated. If its value is `false`, execution continues after the `do` loop. Otherwise the `do` loop is executed again from the beginning.
`for (``initExprs``;``booleanExpr``;``updateExprs``)``statement`	This is a `for` loop. `initExprs` is a comma-separated sequence of expressions, typically one or more definitions or other initializations. `booleanExpr` is a single expression of type boolean. `updateExprs` is a comma-separated sequence of expressions, typically assignments or other updates. To execute a `for` loop, first evaluate `initExprs`. These expressions are evaluated only once, at the beginning of the `for` loop. Now evaluate `booleanExpr`. If its value is `false`, the `for` loop is complete; execution resumes after the entire statement. Otherwise, execute `statement`. Next, evaluate `updateExprs`. Regardless of its value, return to the beginning of this paragraph (evaluate `booleanExprs`).
`label``:``statement`	This is a labeled statement. `label` may be any Java identifier. It does not interfere with variable scoping, etc. `statement`may be any statement, but is often a block or block-containing statement. A labeled statement is executed exactly as though `label` were not present, except that the position within the code of the identifier `label`is recorded. In particular, any `break` or `continue` statements appearing inside `statement` may make reference to `label`. (See `break` and `continue` statements in this chart.)
`break``optionalLabel` `;`	If `optionalLabel` is present, this is a labeled `break` statement; if it is absent, this is an unlabeled `break` statement. A labeled `break` statement exits all enclosing blocks until one whose label matches `optionalLabel` is found. Execution resumes after that block. An unlabeled `break` statement exits the innermost `switch`, `while`, `do`, or `for` statement containing that `break`. Execution resumes after that block.
`continue``optionalLabel` `;`	The syntax of a `continue` statement is identical to that of a `break` statement. A `continue` statement may only appear inside a `while`, `do`, or `for` loop. An unlabeled `continue` statement exits the current iteration of the innermost loop containing that continue statement. Execution resumes at the expression evaluation (test) of `while` and `do` loops, and at the update expression of a `for` loop. A labeled `continue` statement exits the current iteration of the enclosing loop whose label matches `optionalLabel`. Execution resumes at the expression evaluation (test) of `while` and `do` loops, and at the update expression of a `for` loop.
`throw``expression` `;`	Executing a `throw` statement has the effect of exiting every enclosing statement (including those containing method invocations) until a `try` statement with a `catch` clause matching the thrown object (the value of `expression`) is encountered. Execution resumes at this `catch` clause.
`try` `tryBlock``catch (``type name``)` `catchBlock``finally` `finallyBlock`	This is a `try` statement. `tryBlock`, `catchBlock`, and `finallyBlock` are each arbitrary blocks of statements. `type` is any type that implements `Throwable`; name is any Java name. The lines `finally` `finallyBlock` are optional and may be omitted entirely. The lines `catch (``type name` `)``catchBlock` form a `catch` clause. Each `try` statement may have zero or more catch clauses (but exactly one `try` and at most one `finally).` To execute a `try` statement, `tryBlock`is executed. There are three possibilities: 1. If the execution of `tryBlock` completes normally, then execution continues at `finallyBlock` (if present). 2. If a `throw` statement is encountered during the execution of `tryBlock` and the type of the thrown object matches the`type`of one of the `catch` clauses, execution exits`tryBlock` and continues in the `catchBlock` of the first `catch` clause whose `type` matches the type of the thrown object. During execution of `catchBlock`, `name` is bound to the thrown object. After completing this `catchBlock`, execution continues at `finallyBlock` (if present). 3. If execution of `tryBlock` is interrupted for any other reason -- a thrown object that doesn't match a `catch` clause, a `break` or `continue` statement -- execution exits`tryBlock` and continues at `finallyBlock` (if present). If execution of `finallyBlock` completes normally (or if `finallyBlock` is absent, execution continues abnormally, i.e., as though `finallyBlock` had thrown the object or raised the break or continue. That is, execution continues exiting blocks until the `throw`, `break`, or `continue` is resolved.