epubjs
Version:
Render ePub documents in the browser, across many devices
308 lines (299 loc) • 63.7 kB
HTML
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Statements and Expressions</title><link rel="stylesheet" href="core.css" type="text/css"/><meta name="generator" content="DocBook XSL Stylesheets V1.74.0"/></head><body><div class="sect1" title="Statements and Expressions"><div class="titlepage"><div><div><h1 class="title"><a id="learnjava3-CHP-4-SECT-4"/>Statements and Expressions</h1></div></div></div><p>Java <span class="emphasis"><em>statements</em></span> appear inside methods and
classes; they describe all activities of a Java program. Variable
declarations and assignments, such as those in the previous section, are
statements, as are basic language structures such as if/then conditionals
and loops.</p><a id="I_4_tt131"/><pre class="programlisting"> <code class="kt">int</code> <code class="n">size</code> <code class="o">=</code> <code class="mi">5</code><code class="o">;</code>
<code class="k">if</code> <code class="o">(</code> <code class="n">size</code> <code class="o">></code> <code class="mi">10</code> <code class="o">)</code>
<code class="n">doSomething</code><code class="o">();</code>
<code class="k">for</code><code class="o">(</code> <code class="kt">int</code> <code class="n">x</code> <code class="o">=</code> <code class="mi">0</code><code class="o">;</code> <code class="n">x</code> <code class="o"><</code> <code class="n">size</code><code class="o">;</code> <code class="n">x</code><code class="o">++</code> <code class="o">)</code> <code class="o">{</code> <code class="o">...</code> <code class="o">}</code></pre><p><a id="I_indexterm4_id649390" class="indexterm"/> <span class="emphasis"><em>Expressions</em></span> produce values; an
expression is evaluated to produce a result that is to be used as part of
another expression or in a statement. Method calls, object allocations,
and, of course, mathematical expressions are examples of expressions.
Technically, because variable assignments can be used as values for
further assignments or operations (in somewhat questionable programming
style), they can be considered to be both statements and
expressions.</p><a id="I_4_tt132"/><pre class="programlisting"> <code class="k">new</code> <code class="nf">Object</code><code class="o">();</code>
<code class="n">Math</code><code class="o">.</code><code class="na">sin</code><code class="o">(</code> <code class="mf">3.1415</code> <code class="o">);</code>
<code class="mi">42</code> <code class="o">*</code> <code class="mi">64</code><code class="o">;</code></pre><p>One of the tenets of Java is to keep things simple and consistent.
To that end, when there are no other constraints, evaluations and
initializations in Java always occur in the order in which they appear in
the code—from left to right, top to bottom. We’ll see this rule used in
the evaluation of assignment expressions, method calls, and array indexes,
to name a few cases. In some other languages, the order of evaluation is
more complicated or even implementation-dependent. Java removes this
element of danger by precisely and simply defining how the code is
evaluated. This doesn’t mean you should start writing obscure and
convoluted statements, however. Relying on the order of evaluation of
expressions in complex ways is a bad programming habit, even when it
works. It produces code that is hard to read and harder to modify.</p><div class="sect2" title="Statements"><div class="titlepage"><div><div><h2 class="title"><a id="learnjava3-CHP-4-SECT-4.1"/>Statements</h2></div></div></div><p><a id="I_indexterm4_id649432" class="indexterm"/> <a id="I_indexterm4_id649440" class="indexterm"/> <a id="I_indexterm4_id649448" class="indexterm"/> Statements and expressions in Java appear within a
<span class="emphasis"><em>code block</em></span>. A code block is syntactically a series
of statements surrounded by an open curly brace (<code class="literal">{</code>) and a close curly brace (<code class="literal">}</code>). The statements in a code block can include
variable declarations and most of the other sorts of statements and
expressions we mentioned earlier:</p><a id="I_4_tt133"/><pre class="programlisting"> <code class="o">{</code>
<code class="kt">int</code> <code class="n">size</code> <code class="o">=</code> <code class="mi">5</code><code class="o">;</code>
<code class="n">setName</code><code class="o">(</code><code class="s">"Max"</code><code class="o">);</code>
<code class="o">...</code>
<code class="o">}</code></pre><p><a id="I_indexterm4_id649482" class="indexterm"/>Methods, which look like C functions, are in a sense just
code blocks that take parameters and can be called by their names—for
example, the method <code class="literal">setUpDog()</code>:</p><a id="I_4_tt134"/><pre class="programlisting"> <code class="n">setUpDog</code><code class="o">(</code> <code class="n">String</code> <code class="n">name</code> <code class="o">)</code> <code class="o">{</code>
<code class="kt">int</code> <code class="n">size</code> <code class="o">=</code> <code class="mi">5</code><code class="o">;</code>
<code class="n">setName</code><code class="o">(</code> <code class="n">name</code> <code class="o">);</code>
<code class="o">...</code>
<code class="o">}</code></pre><p><a id="I_indexterm4_id649508" class="indexterm"/>Variable declarations are limited in scope to their
enclosing code block—that is, they can’t be seen outside of the nearest
set of braces:</p><a id="I_4_tt135"/><pre class="programlisting"> <code class="o">{</code>
<code class="kt">int</code> <code class="n">i</code> <code class="o">=</code> <code class="mi">5</code><code class="o">;</code>
<code class="o">}</code>
<code class="n">i</code> <code class="o">=</code> <code class="mi">6</code><code class="o">;</code> <code class="c1">// Compile-time error, no such variable i</code></pre><p>In this way, code blocks can be used to arbitrarily group other
statements and variables. The most common use of code blocks, however,
is to define a group of statements for use in a conditional or iterative
statement.</p><div class="sect3" title="if/else conditionals"><div class="titlepage"><div><div><h3 class="title"><a id="learnjava3-CHP-4-SECT-4.1.1"/>if/else conditionals</h3></div></div></div><p><a id="idx10162" class="indexterm"/> <a id="idx10176" class="indexterm"/> <a id="idx10204" class="indexterm"/>We can define an <code class="literal">if/else</code> clause as follows:</p><a id="I_4_tt136"/><pre class="programlisting"> <code class="k">if</code> <code class="o">(</code> <em class="replaceable"><code><code class="n">condition</code></code></em> <code class="o">)</code>
<em class="replaceable"><code><code class="n">statement</code></code></em><code class="o">;</code>
<code class="o">[</code> <code class="k">else</code>
<em class="replaceable"><code><code class="n">statement</code></code></em><code class="o">;</code> <code class="o">]</code></pre><p>(The whole of the preceding example is itself a statement and
could be nested within another <code class="literal">if/else</code> clause.) The <code class="literal">if</code> clause has the common functionality of
taking two different forms: a “one-liner” or a block. The block form
is as follows:</p><a id="I_4_tt138"/><pre class="programlisting"> <code class="k">if</code> <code class="o">(</code> <em class="replaceable"><code><code class="n">condition</code></code></em> <code class="o">)</code> <code class="o">{</code>
<code class="o">[</code> <em class="replaceable"><code><code class="n">statement</code></code></em><code class="o">;</code> <code class="o">]</code>
<code class="o">[</code> <em class="replaceable"><code><code class="n">statement</code></code></em><code class="o">;</code> <code class="o">]</code>
<code class="o">[</code> <code class="o">...</code> <code class="o">]</code>
<code class="o">}</code> <code class="k">else</code> <code class="o">{</code>
<code class="o">[</code> <em class="replaceable"><code><code class="n">statement</code></code></em><code class="o">;</code> <code class="o">]</code>
<code class="o">[</code> <em class="replaceable"><code><code class="n">statement</code></code></em><code class="o">;</code> <code class="o">]</code>
<code class="o">[</code> <code class="o">...</code> <code class="o">]</code>
<code class="o">}</code></pre><p>The <em class="replaceable"><code>condition</code></em> is a Boolean
expression. A Boolean expression is a <a id="I_indexterm4_id649649" class="indexterm"/><code class="literal">true</code> or <a id="I_indexterm4_id649659" class="indexterm"/><code class="literal">false</code> value or an
expression that evaluates to one of those. For example <code class="literal">i == 0</code> is a Boolean expression that tests
whether the integer <code class="literal">i</code> holds the
value <code class="literal">0</code>.</p><p>In the second form, the statements are in code blocks, and all
their enclosed statements are executed if the corresponding (if or
else) branch is taken. Any variables declared within each block are
visible only to the statements within the block. Like the <code class="literal">if/else</code> conditional, most of the remaining
Java statements are concerned with controlling the flow of execution.
They act for the most part like their namesakes in other
languages.<a id="I_indexterm4_id680664" class="indexterm"/><a id="I_indexterm4_id680671" class="indexterm"/><a id="I_indexterm4_id680678" class="indexterm"/></p></div><div class="sect3" title="do/while loops"><div class="titlepage"><div><div><h3 class="title"><a id="learnjava3-CHP-4-SECT-4.1.2"/>do/while loops</h3></div></div></div><p><a id="I_indexterm4_id680691" class="indexterm"/> <a id="I_indexterm4_id680697" class="indexterm"/> <a id="idx10202" class="indexterm"/>The <code class="literal">do</code> and <code class="literal">while</code> iterative statements have the familiar
functionality; their conditional test is also a Boolean
expression:</p><a id="I_4_tt139"/><pre class="programlisting"> <code class="k">while</code> <code class="o">(</code> <em class="replaceable"><code><code class="n">condition</code></code></em> <code class="o">)</code>
<em class="replaceable"><code><code class="n">statement</code></code></em><code class="o">;</code>
<code class="k">do</code>
<em class="replaceable"><code><code class="n">statement</code></code></em><code class="o">;</code>
<code class="k">while</code> <code class="o">(</code> <em class="replaceable"><code><code class="n">condition</code></code></em> <code class="o">);</code></pre><p>For example:</p><a id="I_4_tt140"/><pre class="programlisting"> <code class="k">while</code><code class="o">(</code> <code class="n">queue</code><code class="o">.</code><code class="na">isEmpty</code><code class="o">()</code> <code class="o">)</code>
<code class="n">wait</code><code class="o">();</code></pre><p>Unlike <code class="literal">while</code> or <code class="literal">for</code> loops (which we’ll see next) that test
their conditions first, a <code class="literal">do-while</code>
loop always executes its statement body at least once.<a id="I_indexterm4_id680784" class="indexterm"/></p></div><div class="sect3" title="The for loop"><div class="titlepage"><div><div><h3 class="title"><a id="learnjava3-CHP-4-SECT-4.1.3"/>The for loop</h3></div></div></div><p><a id="idx10161" class="indexterm"/> <a id="idx10177" class="indexterm"/> <a id="idx10205" class="indexterm"/>The most general form of the <code class="literal">for</code> loop is also a holdover from the C
language:</p><a id="I_4_tt141"/><pre class="programlisting"> <code class="k">for</code> <code class="o">(</code> <em class="replaceable"><code><code class="n">initialization</code></code></em><code class="o">;</code> <em class="replaceable"><code><code class="n">condition</code></code></em><code class="o">;</code> <em class="replaceable"><code><code class="n">incrementor</code></code></em> <code class="o">)</code>
<em class="replaceable"><code><code class="n">statement</code></code></em><code class="o">;</code></pre><p>The variable initialization section can declare or initialize
variables that are limited to the scope of the <code class="literal">for</code> statement. The <code class="literal">for</code> loop then begins a possible series of
rounds in which the condition is first checked and, if true, the body
statement (or block) is executed. Following each execution of the
body, the incrementor expressions are evaluated to give them a chance
to update variables before the next round begins:</p><a id="I_4_tt142"/><pre class="programlisting"> <code class="k">for</code> <code class="o">(</code> <code class="kt">int</code> <code class="n">i</code> <code class="o">=</code> <code class="mi">0</code><code class="o">;</code> <code class="n">i</code> <code class="o"><</code> <code class="mi">100</code><code class="o">;</code> <code class="n">i</code><code class="o">++</code> <code class="o">)</code> <code class="o">{</code>
<code class="n">System</code><code class="o">.</code><code class="na">out</code><code class="o">.</code><code class="na">println</code><code class="o">(</code> <code class="n">i</code> <code class="o">);</code>
<code class="kt">int</code> <code class="n">j</code> <code class="o">=</code> <code class="n">i</code><code class="o">;</code>
<code class="o">...</code>
<code class="o">}</code></pre><p>This loop will execute 100 times, printing values from 0 to 99.
Note that the variable <code class="literal">j</code> is local
to the block (visible only to statements within it) and will not be
accessible to the code “after” the <code class="literal">for</code> loop. If the condition of a <code class="literal">for</code> loop returns false on the first check,
the body and incrementor section will never be executed.</p><p>You can use multiple comma-separated expressions in the
initialization and incrementation sections of the <code class="literal">for</code> loop. For example:</p><a id="I_4_tt143"/><pre class="programlisting"> <code class="k">for</code> <code class="o">(</code><code class="kt">int</code> <code class="n">i</code> <code class="o">=</code> <code class="mi">0</code><code class="o">,</code> <code class="n">j</code> <code class="o">=</code> <code class="mi">10</code><code class="o">;</code> <code class="n">i</code> <code class="o"><</code> <code class="n">j</code><code class="o">;</code> <code class="n">i</code><code class="o">++,</code> <code class="n">j</code><code class="o">--</code> <code class="o">)</code> <code class="o">{</code>
<code class="o">...</code>
<code class="o">}</code></pre><p>You can also initialize existing variables from outside the
scope of the <code class="literal">for</code> loop within the
initializer block. You might do this if you wanted to use the end
value of the loop variable elsewhere:<a id="I_indexterm4_id680939" class="indexterm"/><a id="I_indexterm4_id680946" class="indexterm"/><a id="I_indexterm4_id680953" class="indexterm"/></p><a id="I_4_tt144"/><pre class="programlisting"> <code class="kt">int</code> <code class="n">x</code><code class="o">;</code>
<code class="k">for</code><code class="o">(</code> <code class="n">x</code> <code class="o">=</code> <code class="mi">0</code><code class="o">;</code> <code class="n">hasMoreValue</code><code class="o">();</code> <code class="n">x</code><code class="o">++</code> <code class="o">)</code>
<code class="n">getNextValue</code><code class="o">();</code>
<code class="n">System</code><code class="o">.</code><code class="na">out</code><code class="o">.</code><code class="na">println</code><code class="o">(</code> <code class="n">x</code> <code class="o">);</code></pre></div><div class="sect3" title="The enhanced for loop"><div class="titlepage"><div><div><h3 class="title"><a id="learnjava3-CHP-4-SECT-4.1.4"/>The enhanced for loop</h3></div></div></div><p><a id="idx10175" class="indexterm"/> <a id="idx10203" class="indexterm"/>Java’s auspiciously dubbed “enhanced <code class="literal">for</code> loop” acts like the “foreach” statement
in some other languages, iterating over a series of values in an array
or other type of collection:</p><a id="I_4_tt145"/><pre class="programlisting"> <code class="k">for</code> <code class="o">(</code> <em class="replaceable"><code><code class="n">varDeclaration</code></code></em> <code class="o">:</code> <em class="replaceable"><code><code class="n">iterable</code></code></em> <code class="o">)</code>
<em class="replaceable"><code><code class="n">statement</code></code></em><code class="o">;</code></pre><p>The enhanced <code class="literal">for</code> loop can be
used to loop over arrays of any type as well as any kind of Java
object that implements the <a id="I_indexterm4_id681039" class="indexterm"/><code class="literal">java.lang.Iterable</code>
interface. This includes most of the classes of the Java Collections
API. We’ll talk about arrays in this and the next chapter; <a class="xref" href="ch11.html" title="Chapter 11. Core Utilities">Chapter 11</a> covers Java Collections. Here are a
couple of examples:</p><a id="I_4_tt146"/><pre class="programlisting"> <code class="kt">int</code> <code class="o">[]</code> <code class="n">arrayOfInts</code> <code class="o">=</code> <code class="k">new</code> <code class="kt">int</code> <code class="o">[]</code> <code class="o">{</code> <code class="mi">1</code><code class="o">,</code> <code class="mi">2</code><code class="o">,</code> <code class="mi">3</code><code class="o">,</code> <code class="mi">4</code> <code class="o">};</code>
<code class="k">for</code><code class="o">(</code> <code class="kt">int</code> <code class="n">i</code> <code class="o">:</code> <code class="n">arrayOfInts</code> <code class="o">)</code>
<code class="n">System</code><code class="o">.</code><code class="na">out</code><code class="o">.</code><code class="na">println</code><code class="o">(</code> <code class="n">i</code> <code class="o">);</code>
<code class="n">List</code><code class="o"><</code><code class="n">String</code><code class="o">></code> <code class="n">list</code> <code class="o">=</code> <code class="k">new</code> <code class="n">ArrayList</code><code class="o"><</code><code class="n">String</code><code class="o">>();</code>
<code class="n">list</code><code class="o">.</code><code class="na">add</code><code class="o">(</code><code class="s">"foo"</code><code class="o">);</code>
<code class="n">list</code><code class="o">.</code><code class="na">add</code><code class="o">(</code><code class="s">"bar"</code><code class="o">);</code>
<code class="k">for</code><code class="o">(</code> <code class="n">String</code> <code class="n">s</code> <code class="o">:</code> <code class="n">list</code> <code class="o">)</code>
<code class="n">System</code><code class="o">.</code><code class="na">out</code><code class="o">.</code><code class="na">println</code><code class="o">(</code> <code class="n">s</code> <code class="o">);</code></pre><p>Again, we haven’t discussed arrays or the <code class="literal">List</code> class and special syntax in this
example. What we’re showing here is the enhanced <code class="literal">for</code> loop iterating over an array of integers
and also a list of string values. In the second case, the <code class="literal">List</code> implements the <code class="literal">Iterable</code> interface and thus can be a target
of the <code class="literal">for</code> loop.<a id="I_indexterm4_id681104" class="indexterm"/><a id="I_indexterm4_id681112" class="indexterm"/></p></div><div class="sect3" title="switch statements"><div class="titlepage"><div><div><h3 class="title"><a id="learnjava3-CHP-4-SECT-4.1.5"/>switch statements</h3></div></div></div><p><a id="idx10178" class="indexterm"/> <a id="idx10179" class="indexterm"/> <a id="idx10206" class="indexterm"/>The most common form of the Java <code class="literal">switch</code> statement takes an integer (or a
numeric type argument that can be automatically “promoted” to an
integer type), a string type argument, or an “enum” type (discussed
shortly) and selects among a number of alternative, constant
<a id="I_indexterm4_id681174" class="indexterm"/><code class="literal">case</code>
branches:<sup>[<a id="id1637040" href="#ftn.id1637040" class="footnote">8</a>]</sup></p><a id="I_4_tt147"/><pre class="programlisting"> <code class="k">switch</code> <code class="o">(</code> <em class="replaceable"><code><code class="n">expression</code></code></em> <code class="o">)</code>
<code class="o">{</code>
<code class="k">case</code> <em class="replaceable"><code><code class="n">constantExpression</code></code></em> <code class="o">:</code>
<em class="replaceable"><code><code class="n">statement</code></code></em><code class="o">;</code>
<code class="o">[</code> <code class="k">case</code> <em class="replaceable"><code><code class="n">constantExpression</code> <code class="o">:</code></code></em><em class="replaceable"><code><code class="n">statement</code></code></em><code class="o">;</code> <code class="o">]</code>
<code class="o">...</code>
<code class="o">[</code> <code class="k">default</code> <code class="o">:</code>
<em class="replaceable"><code><code class="n">statement</code></code></em><code class="o">;</code> <code class="o">]</code>
<code class="o">}</code></pre><p>The case expression for each branch must evaluate to a different
constant integer or string value at compile time. Strings are compared
using the <code class="literal">String </code><a id="I_indexterm4_id681229" class="indexterm"/><code class="literal">equals()</code> method,
which we’ll discuss in more detail in <a class="xref" href="ch10.html" title="Chapter 10. Working with Text">Chapter 10</a>. An optional <a id="I_indexterm4_id681247" class="indexterm"/><code class="literal">default</code> case can be
specified to catch unmatched conditions. When executed, the switch
simply finds the branch matching its conditional expression (or the
default branch) and executes the corresponding statement. But that’s
not the end of the story. Perhaps counterintuitively, the <code class="literal">switch</code> statement then continues executing
branches after the matched branch until it hits the end of the switch
or a special statement called <code class="literal">break</code>. Here are a couple of examples:</p><a id="I_4_tt148"/><pre class="programlisting"> <code class="kt">int</code> <code class="n">value</code> <code class="o">=</code> <code class="mi">2</code><code class="o">;</code>
<code class="k">switch</code><code class="o">(</code> <code class="n">value</code> <code class="o">)</code> <code class="o">{</code>
<code class="k">case</code> <code class="mi">1</code><code class="o">:</code>
<code class="n">System</code><code class="o">.</code><code class="na">out</code><code class="o">.</code><code class="na">println</code><code class="o">(</code> <code class="mi">1</code> <code class="o">);</code>
<code class="k">case</code> <code class="mi">2</code><code class="o">:</code>
<code class="n">System</code><code class="o">.</code><code class="na">out</code><code class="o">.</code><code class="na">println</code><code class="o">(</code> <code class="mi">2</code> <code class="o">);</code>
<code class="k">case</code> <code class="mi">3</code><code class="o">:</code>
<code class="n">System</code><code class="o">.</code><code class="na">out</code><code class="o">.</code><code class="na">println</code><code class="o">(</code> <code class="mi">3</code> <code class="o">);</code>
<code class="o">}</code>
<code class="c1">// prints 2, 3!</code></pre><p>Using <code class="literal">break</code> to terminate each
branch is more common:</p><a id="I_4_tt149"/><pre class="programlisting"> <code class="kt">int</code> <code class="n">retValue</code> <code class="o">=</code> <code class="n">checkStatus</code><code class="o">();</code>
<code class="k">switch</code> <code class="o">(</code> <code class="n">retVal</code> <code class="o">)</code>
<code class="o">{</code>
<code class="k">case</code> <code class="n">MyClass</code><code class="o">.</code><code class="na">GOOD</code> <code class="o">:</code>
<code class="c1">// something good</code>
<code class="k">break</code><code class="o">;</code>
<code class="k">case</code> <code class="n">MyClass</code><code class="o">.</code><code class="na">BAD</code> <code class="o">:</code>
<code class="c1">// something bad</code>
<code class="k">break</code><code class="o">;</code>
<code class="k">default</code> <code class="o">:</code>
<code class="c1">// neither one</code>
<code class="k">break</code><code class="o">;</code>
<code class="o">}</code></pre><p>In this example, only one branch—<code class="literal">GOOD</code>, <code class="literal">BAD</code>, or the default—is executed. The “fall
through” behavior of the switch is justified when you want to cover
several possible case values with the same statement without resorting
to a bunch of <code class="literal">if/else</code>
statements:</p><a id="I_4_tt150"/><pre class="programlisting"> <code class="kt">int</code> <code class="n">value</code> <code class="o">=</code> <code class="n">getSize</code><code class="o">();</code>
<code class="k">switch</code><code class="o">(</code> <code class="n">value</code> <code class="o">)</code> <code class="o">{</code>
<code class="k">case</code> <code class="nl">MINISCULE:</code>
<code class="k">case</code> <code class="nl">TEENYWEENIE:</code>
<code class="k">case</code> <code class="nl">SMALL:</code>
<code class="n">System</code><code class="o">.</code><code class="na">out</code><code class="o">.</code><code class="na">println</code><code class="o">(</code><code class="s">"Small"</code> <code class="o">);</code>
<code class="k">break</code><code class="o">;</code>
<code class="k">case</code> <code class="nl">MEDIUM:</code>
<code class="n">System</code><code class="o">.</code><code class="na">out</code><code class="o">.</code><code class="na">println</code><code class="o">(</code><code class="s">"Medium"</code> <code class="o">);</code>
<code class="k">break</code><code class="o">;</code>
<code class="k">case</code> <code class="nl">LARGE:</code>
<code class="k">case</code> <code class="nl">EXTRALARGE:</code>
<code class="n">System</code><code class="o">.</code><code class="na">out</code><code class="o">.</code><code class="na">println</code><code class="o">(</code><code class="s">"Large"</code> <code class="o">);</code>
<code class="k">break</code><code class="o">;</code>
<code class="o">}</code></pre><p>This example effectively groups the six possible values into
three cases.</p></div><div class="sect3" title="Enumerations and switch statements"><div class="titlepage"><div><div><h3 class="title"><a id="id1519682"/>Enumerations and switch statements</h3></div></div></div><p><a id="I_indexterm4_id681346" class="indexterm"/>Enumerations are intended to replace much of the usage
of integer constants for situations like the one just discussed with a
typesafe alternative. Enumerations use objects as their values instead
of integers but preserve the notion of ordering and comparability.
We’ll see in <a class="xref" href="ch05.html" title="Chapter 5. Objects in Java">Chapter 5</a> that enumerations are
declared much like classes and that the values can be “imported” into
the code of your application to be used just like constants. For
example:</p><a id="I_4_tt151"/><pre class="programlisting"> <code class="kd">enum</code> <code class="n">Size</code> <code class="o">{</code> <code class="n">Small</code><code class="o">,</code> <code class="n">Medium</code><code class="o">,</code> <code class="n">Large</code> <code class="o">}</code></pre><p>You can use enumerations in switches in the same way that the
previous switch examples used integer constants. In fact, it is much
safer to do so because the enumerations have real types and the
compiler does not let you mistakenly add cases that do not match any
value or mix values from different enumerations.</p><a id="I_4_tt152"/><pre class="programlisting"> <code class="c1">// usage</code>
<code class="n">Size</code> <code class="n">size</code> <code class="o">=</code> <code class="o">...;</code>
<code class="k">switch</code> <code class="o">(</code> <code class="n">size</code> <code class="o">)</code> <code class="o">{</code>
<code class="k">case</code> <code class="nl">Small:</code>
<code class="o">...</code>
<code class="k">case</code> <code class="nl">Medium:</code>
<code class="o">...</code>
<code class="k">case</code> <code class="nl">Large:</code>
<code class="o">...</code>
<code class="o">}</code></pre><p><a class="xref" href="ch05.html" title="Chapter 5. Objects in Java">Chapter 5</a> provides more details about
enumerations.<a id="I_indexterm4_id681396" class="indexterm"/><a id="I_indexterm4_id681404" class="indexterm"/><a id="I_indexterm4_id681411" class="indexterm"/></p></div><div class="sect3" title="break/continue"><div class="titlepage"><div><div><h3 class="title"><a id="learnjava3-CHP-4-SECT-4.1.6"/>break/continue</h3></div></div></div><p><a id="idx10137" class="indexterm"/> <a id="idx10174" class="indexterm"/> <a id="idx10201" class="indexterm"/>The Java <code class="literal">break</code>
statement and its friend <code class="literal">continue</code>
can also be used to cut short a loop or conditional statement by
jumping out of it. A <code class="literal">break</code> causes
Java to stop the current block statement and resume execution after
it. In the following example, the <a id="I_indexterm4_id681480" class="indexterm"/><code class="literal">while</code> loop goes on
endlessly until the <code class="literal">condition()</code>
method returns true, triggering a <code class="literal">break</code> statement that stops the loop and
proceeds at the point marked “after while.”</p><a id="I_4_tt153"/><pre class="programlisting"> <code class="k">while</code><code class="o">(</code> <code class="kc">true</code> <code class="o">)</code> <code class="o">{</code>
<code class="k">if</code> <code class="o">(</code> <code class="n">condition</code><code class="o">()</code> <code class="o">)</code>
<code class="k">break</code><code class="o">;</code>
<code class="o">}</code>
<code class="c1">// after while</code></pre><p>A <code class="literal">continue</code> statement causes
<a id="I_indexterm4_id681520" class="indexterm"/><code class="literal">for</code> and <code class="literal">while</code> loops to move on to their next
iteration by returning to the point where they check their condition.
The following example prints the numbers 0 through 99, skipping number
33.</p><a id="I_4_tt154"/><pre class="programlisting"> <code class="k">for</code><code class="o">(</code> <code class="kt">int</code> <code class="n">i</code><code class="o">=</code><code class="mi">0</code><code class="o">;</code> <code class="n">i</code> <code class="o"><</code> <code class="mi">100</code><code class="o">;</code> <code class="n">i</code><code class="o">++</code> <code class="o">)</code> <code class="o">{</code>
<code class="k">if</code> <code class="o">(</code> <code class="n">i</code> <code class="o">==</code> <code class="mi">33</code> <code class="o">)</code>
<code class="k">continue</code><code class="o">;</code>
<code class="n">System</code><code class="o">.</code><code class="na">out</code><code class="o">.</code><code class="na">println</code><code class="o">(</code> <code class="n">i</code> <code class="o">);</code>
<code class="o">}</code></pre><p>The <code class="literal">break</code> and <code class="literal">continue</code> statements look like those in the C
language, but Java’s forms have the additional ability to take a label
as an argument and jump out multiple levels to the scope of the
labeled point in the code. This usage is not very common in day-to-day
Java coding, but may be important in special cases. Here is an
outline:</p><a id="I_4_tt155"/><pre class="programlisting"> <code class="nl">labelOne:</code>
<code class="k">while</code> <code class="o">(</code> <em class="replaceable"><code><code class="n">condition</code></code></em> <code class="o">)</code> <code class="o">{</code>
<code class="o">...</code>
<code class="nl">labelTwo:</code>
<code class="k">while</code> <code class="o">(</code> <em class="replaceable"><code><code class="n">condition</code></code></em> <code class="o">)</code> <code class="o">{</code>
<code class="o">...</code>
<code class="c1">// break or continue point</code>
<code class="o">}</code>
<code class="c1">// after labelTwo</code>
<code class="o">}</code>
<code class="c1">// after labelOne</code></pre><p>Enclosing statements, such as code blocks, conditionals, and
loops, can be labeled with identifiers like <code class="literal">labelOne</code> and <code class="literal">labelTwo</code>. In this example, a <code class="literal">break</code> or <code class="literal">continue</code> without argument at the indicated
position has the same effect as the earlier examples. A <code class="literal">break</code> causes processing to resume at the
point labeled “after labelTwo”; a <code class="literal">continue</code> immediately causes the <code class="literal">labelTwo</code> loop to return to its condition
test.</p><p>The statement <code class="literal">break labelTwo</code>
at the indicated point has the same effect as an ordinary <code class="literal">break</code>, but <code class="literal">break
labelOne</code> breaks both levels and resumes at the point labeled
“after labelOne.” Similarly, <code class="literal">continue
labelTwo</code> serves as a normal <code class="literal">continue</code>, but <code class="literal">continue labelOne</code> returns to the test of the
<code class="literal">labelOne</code> loop. Multilevel <code class="literal">break</code> and <code class="literal">continue</code> statements remove the main
justification for the evil <code class="literal">goto</code>
statement in C/C++.</p><p>There are a few Java statements we aren’t going to discuss right
now. The <code class="literal">try</code> , <code class="literal">catch</code>, and <code class="literal">finally</code> statements are used in exception
handling, as we’ll discuss later in this chapter. The <code class="literal">synchronized</code> statement in Java is used to
coordinate access to statements among
multiple threads of execution; see <a class="xref" href="ch09.html" title="Chapter 9. Threads">Chapter 9</a> for a discussion of thread synchronization.<a id="I_indexterm4_id681735" class="indexterm"/><a id="I_indexterm4_id681742" class="indexterm"/><a id="I_indexterm4_id681749" class="indexterm"/></p></div><div class="sect3" title="Unreachable statements"><div class="titlepage"><div><div><h3 class="title"><a id="learnjava3-CHP-4-SECT-4.1.7"/>Unreachable statements</h3></div></div></div><p><a id="I_indexterm4_id681763" class="indexterm"/> <a id="I_indexterm4_id681771" class="indexterm"/> <a id="I_indexterm4_id681782" class="indexterm"/>On a final note, we should mention that the Java
compiler flags “unreachable” statements as compile-time errors. An
unreachable statement is one that the compiler determines won’t be
called at all. Of course, many methods may never actually be called in
your code, but the compiler detects only those that it can “prove” are
never called by simple checking at compile time. For example, a method
with an unconditional return statement in the middle of it causes a
compile-time error, as does a method with a conditional that the
compiler can tell will never be fulfilled:</p><a id="I_4_tt156"/><pre class="programlisting"> <code class="k">if</code> <code class="o">(</code><code class="mi">1</code> <code class="o"><</code> <code class="mi">2</code><code class="o">)</code>
<code class="k">return</code><code class="o">;</code>
<code class="c1">// unreachable statements</code></pre></div></div><div class="sect2" title="Expressions"><div class="titlepage"><div><div><h2 class="title"><a id="learnjava3-CHP-4-SECT-4.2"/>Expressions</h2></div></div></div><p>An expression produces a result, or value, when it is evaluated.
The value of an expression can be a numeric type, as in an arithmetic
expression; a reference type, as in an object allocation; or the special
type, <a id="I_indexterm4_id681814" class="indexterm"/><code class="literal">void</code>, which is the
declared type of a method that doesn’t return a value. In the last case,
the expression is evaluated only for its <span class="emphasis"><em>side effects</em></span>; that is, the work it
does aside from producing a value. The type of an expression is known at
compile time. The value produced at runtime is either of this type or in
the case of a reference type, a compatible (assignable) subtype.</p><div class="sect3" title="Operators"><div class="titlepage"><div><div><h3 class="title"><a id="learnjava3-CHP-4-SECT-4.2.1"/>Operators</h3></div></div></div><p><a id="idx10158" class="indexterm"/> <a id="idx10167" class="indexterm"/> <a id="idx10199" class="indexterm"/>Java supports almost all standard operators from the C
language. These operators also have the same precedence in Java as
they do in C, as shown in <a class="xref" href="ch04s04.html#learnjava3-CHP-4-TABLE-3" title="Table 4-3. Java operators">Table 4-3</a>.</p><div class="table"><a id="learnjava3-CHP-4-TABLE-3"/><p class="title">Table 4-3. Java operators</p><div class="table-contents"><table summary="Java operators" style="border-collapse: collapse;border-top: 0.5pt solid ; border-bottom: 0.5pt solid ; "><colgroup><col/><col/><col/><col/></colgroup><thead><tr><th style="text-align: left"><p>Precedence</p></th><th style="text-align: left"><p>Operator</p></th><th style="text-align: left"><p>Operand type</p></th><th style="text-align: left"><p>Description</p></th></tr></thead><tbody><tr><td style="text-align: left"><p> <a id="I_indexterm4_id681952" class="indexterm"/>1</p></td><td style="text-align: left"><p> <a id="I_indexterm4_id681964" class="indexterm"/> <a id="I_indexterm4_id681970" class="indexterm"/>++, —</p></td><td style="text-align: left"><p>Arithmetic</p></td><td style="text-align: left"><p> <a id="I_indexterm4_id681987" class="indexterm"/> <a id="I_indexterm4_id681994" class="indexterm"/>Increment and decrement</p></td></tr><tr><td style="text-align: left"><p>1</p></td><td style="text-align: left"><p> <a id="I_indexterm4_id682012" class="indexterm"/> <a id="I_indexterm4_id682018" class="indexterm"/> <a id="I_indexterm4_id682025" class="indexterm"/> <a id="I_indexterm4_id682031" class="indexterm"/>+, -</p></td><td style="text-align: left"><p>Arithmetic</p></td><td style="text-align: left"><p> <a id="I_indexterm4_id682048" class="indexterm"/> Unary plus and minus</p></td></tr><tr><td style="text-align: left"><p> <a id="I_indexterm4_id682061" class="indexterm"/>1</p></td><td style="text-align: left"><p> <a id="I_indexterm4_id682072" class="indexterm"/> <a id="I_indexterm4_id682079" class="indexterm"/>~</p></td><td style="text-align: left"><p>Integral</p></td><td style="text-align: left"><p>Bitwise complement</p></td></tr><tr><td style="text-align: left"><p> <a id="I_indexterm4_id682102" class="indexterm"/>1</p></td><td style="text-align: left"><p> <a id="I_indexterm4_id682114" class="indexterm"/> <a id="I_indexterm4_id682121" class="indexterm"/>!</p></td><td style="text-align: left"><p>Boolean</p></td><td style="text-align: left"><p>Logical complement</p></td></tr><tr><td style="text-align: left"><p>1</p></td><td style="text-align: left"><p> <code class="literal">(</code> <em class="replaceable"><code>type</code></em>
<code class="literal">)</code> </p></td><td style="text-align: left"><p>Any</p></td><td style="text-align: left"><p>Cast</p></td></tr><tr><td style="text-align: left"><p>2</p></td><td style="text-align: left"><p> <a id="I_indexterm4_id682185" class="indexterm"/> <a id="I_indexterm4_id682192" class="indexterm"/> <a id="I_indexterm4_id682198" class="indexterm"/> <a id="I_indexterm4_id682206" class="indexterm"/> <a id="I_indexterm4_id682217" class="indexterm"/> <a id="I_indexterm4_id682223" class="indexterm"/>*, /, %</p></td><td style="text-align: left"><p>Arithmetic</p></td><td style="text-align: left"><p> <a id="I_indexterm4_id682240" class="indexterm"/> <a id="I_indexterm4_id682247" class="indexterm"/> <a id="I_indexterm4_id682253" class="indexterm"/>Multiplication, division,
remainder</p></td></tr><tr><td style="text-align: left"><p>3</p></td><td style="text-align: left"><p> <a id="I_indexterm4_id682272" class="indexterm"/> +, -</p></td><td style="text-align: left"><p>Arithmetic</p></td><td style="text-align: left"><p>Addition and
subtraction</p></td></tr><tr><td style="text-align: left"><p>3</p></td><td style="text-align: left"><p>+</p></td><td style="text-align: left"><p>String</p></td><td style="text-align: left"><p> <a id="I_indexterm4_id682311" class="indexterm"/>String concatenation</p></td></tr><tr><td style="text-align: left"><p>4</p></td><td style="text-align: left"><p> <a id="I_indexterm4_id682329" class="indexterm"/><<</p></td><td style="text-align: left"><p>Integral</p></td><td style="text-align: left"><p>Left shift</p></td></tr><tr><td style="text-align: left"><p>4</p></td><td style="text-align: left"><p> <a id="I_indexterm4_id682358" class="indexterm"/>>></p></td><td style="text-align: left"><p>Integral</p></td><td style="text-align: left"><p>Right shift with sign
extension</p></td></tr><tr><td style="text-align: left"><p>4</p></td><td style="text-align: left"><p> <a id="I_indexterm4_id682387" class="indexterm"/>>>></p></td><td style="text-align: left"><p>Integral</p></td><td style="text-align: left"><p>Right shift with no
extension</p></td></tr><tr><td style="text-align: left"><p>5</p></td><td style="text-align: left"><p> <a id="I_indexterm4_id682417" class="indexterm"/> <a id="I_indexterm4_id682423" class="indexterm"/> <a id="I_indexterm4_id682430" class="indexterm"/> <a id="I_indexterm4_id682436" class="indexterm"/><, <=, >, >=</p></td><td style="text-align: left"><p>Arithmetic</p></td><td style="text-align: left"><p>Numeric comparison</p></td></tr><tr><td style="text-align: left"><p>5</p></td><td style="text-align: left"><p> <code class="literal">instanceof</code> </p></td><td style="text-align: left"><p>Object</p></td><td style="text-align: left"><p>Type comparison</p></td></tr><tr><td style="text-align: left"><p> <a id="I_indexterm4_id682487" class="indexterm"/>6</p></td><td style="text-align: left"><p> <a id="I_indexterm4_id682499" class="indexterm"/> <a id="I_indexterm4_id682505" class="indexterm"/>==, !=</p></td><td style="text-align: left"><p>Primitive</p></td><td style="text-align: left"><p> <a id="I_indexterm4_id682522" class="indexterm"/> <a id="I_indexterm4_id682528" class="indexterm"/>Equality and inequality of value</p></td></tr><tr><td style="text-align: left"><p>6</p></td><td style="text-align: left"><p>==, !=</p></td><td style="text-align: left"><p>Object</p></td><td style="text-align: left"><p>Equality and inequality of
reference</p></td></tr><tr><td style="text-align: left"><p> <a id="I_indexterm4_id682564" class="indexterm"/>7</p></td><td style="text-align: left"><p> <a id="I_indexterm4_id682575" class="indexterm"/> <a id="I_indexterm4_id682582" class="indexterm"/>&</p></td><td style="text-align: left"><p>Integral</p></td><td style="text-align: left"><p>Bitwise AND</p></td></tr><tr><td style="text-align: left"><p>7</p></td><td style="text-align: left"><p>&</p></td><td style="text-align: left"><p>Boolean</p></td><td style="text-align: left"><p>Boolean AND</p></td></tr><tr><td style="text-align: left"><p> <a id="I_indexterm4_id682627" class="indexterm"/>8</p></td><td style="text-align: left"><p> <a id="I_indexterm4_id682639" class="indexterm"/> <a id="I_indexterm4_id682649" class="indexterm"/>^</p></td><td style="text-align: left"><p>Integral</p></td><td style="text-align: left"><p>Bitwise XOR</p></td></tr><tr><td style="text-align: left"><p>8</p></td><td style="text-align: left"><p>^</p></td><td style="text-align: left"><p>Boolean</p></td><td style="text-align: left"><p>Boolean XOR</p></td></tr><tr><td style="text-align: left"><p> <a id="idx10168" class="indexterm"/>9</p></td><td style="text-align: left"><p> <a id="I_indexterm4_id682714" class="indexterm"/> <a id="I_indexterm4_id682720" class="indexterm"/>|</p></td><td style="text-align: left"><p>Integral</p></td><td style="text-align: left"><p>Bitwise OR</p></td></tr><tr><td style="text-align: left"><p>9</p></td><td style="text-align: left"><p>|</p></td><td style="text-align: left"><p>Boolean</p></td><td style="text-align: left"><p>Boolean OR</p></td></tr><tr><td style="text-align: left"><p>10</p></td><td style="text-align: left"><p> <a id="I_indexterm4_id682770" class="indexterm"/>&&</p></td><td style="text-align: left"><p>Boolean</p></td><td style="text-align: left"><p>Conditional AND</p></td></tr><tr><td style="text-align: left"><p>11</p></td><td style="text-align: left"><p> <a id="I_indexterm4_id682799" class="indexterm"/>||</p></td><td style="text-align: left"><p>Boolean</p></td><td style="text-align: left"><p>Conditional OR<a id="I_indexterm4_id682816" class="indexterm"/></p></td></tr><tr><td style="text-align: left"><p>12</p></td><td style="text-align: left"><p> <a id="I_indexterm4_id682834" class="indexterm"/>?:</p></td><td style="text-align: left"><p>N/A</p></td><td style="text-align: left"><p> <a id="I_indexterm4_id682851" class="indexterm"/>Conditional ternary operator</p></td></tr><tr><td style="text-align: left"><p>13</p></td><td style="text-align: left"><p> <a id="I_indexterm4_id682870" class="indexterm"/> <a id="I_indexterm4_id682876" class="indexterm"/>=</p></td><td style="text-align: left"><p>Any</p></td><td style="text-align: left"><p> <a id="I_indexterm4_id682893" class="indexterm"/>Assignment</p></td></tr></tbody></table></div></div><p>We should also note that the percent (<code class="literal">%</code>) operator is not strictly a modulo, but a
remainder, and can have a negative value.</p><p>Java also adds some new operators. As we’ve seen, the <code class="literal">+</code> operator can be used with <code class="literal">String</code> values to perform string
concatenation. Because all integral types in Java are signed values,
the <code class="literal">>></code> operator can be used
to perform a right-arithmetic-shift operation with sign extension. The
<code class="literal">>>></code> operator treats the
operand as an unsigned number and performs a right-arithmetic-shift
with no sign extension. The <code class="literal">new</code>
operator is used to create objects; we will discuss it in detail
shortly.<a id="I_indexterm4_id682943" class="indexterm"/><a id="I_indexterm4_id682950" class="indexterm"/><a id="I_indexterm4_id682957" class="indexterm"/></p></div><div class="sect3" title="Assignment"><div class="titlepage"><div><div><h3 class="title"><a id="learnjava3-CHP-4-SECT-4.2.2"/>Assignment</h3></div></div></div><p><a id="idx10156" class="indexterm"/> <a id="idx10197" class="indexterm"/>While variable initialization (i.e., declaration and
assignment together) is considered a statement with no resulting
value, variable assignment alone is an expression:</p><a id="I_4_tt157"/><pre class="programlisting"> <code class="kt">int</code> <code class="n">i</code><code class="o">,</code> <code class="n">j</code><code class="o">;</code> <code class="c1">// statement</code>
<code class="n">i</code> <code class="o">=</code> <code class="mi">5</code><code class="o">;</c