Scjp 5 Study Guide Ch. 5

Front 1

the only legal expression in an if statement is a ___ expression

Back 1

boolean, in other words an expression that resolves to a boolean or a Boolean variable

Front 2

watch out for ___ that can be mistaken for boolean equality (==) tests:

Back 2

boolean assignments (=)

Front 3

curly braces are optional for if blocks that ___. but watch out for misleading indentations

Back 3

have only one conditional statement

Front 4

switch statements can evaluate only to ___

Back 4

enums or the byte, short, int, and char data types

Front 5

the ___ constant must be a literal or final variable, or a constant expression, including an enum

Back 5

case, you cannot have a case that includes a non-final variable, or a range of values

Front 6

unless there is a ___ statement, the matching case is not the only case code that runs

Back 6

break

Front 7

the ___ keyword should be used in a switch statement if you want to run some code when none of the case values match the conditional value

Back 7

default

Front 8

the ___ ___ can be located anywhere in the switch block, so if no case matches, the ___ ___ will be entered, and if the default does not contain a break, then code will continue to execute (fall-through) to the end of the switch or until the break statement is encountered

Back 8

default block

Front 9

a basic for statement has three parts:

Back 9

declaration and/or initialization, boolean evaluation, and the iteration expression

Front 10

if a variable is incremented or evaluated within a basic for loop, it must be ___

Back 10

declared before the loop, or within the for loop declaration

Front 11

a variable declared (not just initialized) within the basic for loop declaration cannot be

Back 11

accessed outside the for loop (in other words, code below the for loop won't be able to use the variable)

Front 12

you can/can't initialize more than one variable of the same type in the first part of the basic for loop declaration

Back 12

can, each initialization must be separated by a comma

Front 13

an enhanced for statement (new as of Java 5), has two parts, the ___ and the ___. it is used only to loop through arrays or collections

Back 13

declaration and the expression

Front 14

with an enhanced for, the expression is the ___ or ___ through which you want to loop

Back 14

array or collection

Front 15

you cannot use a ___ as a condition for an if statement or looping construct. you can't for example say if(x) unless x is a boolean variable

Back 15

number (old C-style language construct) or anything that does not evaluate to a boolean value

Front 16

the ___ ___ will enter the body of the loop at least once, even if the test condition is not met

Back 16

do loop

Front 17

an ___ ___ ___ will cause the current iteration of the inner-most looping construct to stop and the line of code following the loop to run

Back 17

unlabeled break statement

Front 18

an ___ ___ ___ will cause: the current iteration of the inner-most loop to stop, the condition of that loop to be checked, and if the condition is met, the loop to run again

Back 18

unlabeled continue statement

Front 19

if the break statement or the continue statement is labeled

Back 19

it will cause similar action to occur on the labeled loop, not the innermost loop

Front 20

exceptions come in two flavors:

Back 20

checked and unchecked

Front 21

___ exceptions include all subtypes of Exception, excluding classes that extend RuntimeException

Back 21

checked

Front 22

checked exceptions are subject to the handle or declare rule; any method that might throw a checked exception (including methods that invoke methods that can throw a checked exception) must

Back 22

either declare the exception using throws, or handle the exception with an appropriate try/catch

Front 23

subtypes of Error or RuntimeException are unchecked, so the compiler ___. you're free to handle them, or to declare them, but the compiler doesn't care one way or the other

Back 23

doesn't enforce the handle or declare rule

Front 24

if you use an optional ___ block, it will always be invoked, regardless of whether an exception in the corresponding try is thrown or not, and regardless of whether a thrown exception is caught or not

Back 24

finally

Front 25

the only exception to the finally-will-always-be-called rule is that a finally will not be invoked if the ___. that could happen if code from the try or catch blocks calls System.exit()

Back 25

JVM shuts down

Front 26

just because finally is invoked

Back 26

does not mean it will complete. code in the finally block could itself raise an exception or issue a System.exit()

Front 27

uncaught exceptions propagate back through the

Back 27

call stack, starting from the method where the exception is thrown and ending with either the first method that has a corresponding catch for that exception type or a JVM shutdown (which happens if the exception gets to main(), and main() is "ducking" the exception by declaring it)

Front 28

you can create you own exceptions, normally by

Back 28

extending Exception or one of its subtypes. your exception will then be considered a checked exception, and the compiler will enforce the handle or declare rule for the exception

Front 29

all catch blocks must be ordered from ___. if you have a catch clause for both IOException and Exception, you must put the catch for IOException first in your code. otherwise, the IOException would be caught by catch (Exception e), because a catch argument can catch the specified exception or any of its subtypes! the compiler will stop you from defining catch clauses that can never be reached

Back 29

most specific to most general

Front 30

some exceptions are created by programmers

Back 30

some by the JVM

Front 31

___ give you a way to test your assumptions during development and debugging

Back 31

assertions

Front 32

assertions are typically ___ during testing but ___ during development and debugging

Back 32

enabled, disabled

Front 33

you can use assert as a ___ or an ___, but not both together. to compile older code that uses assert as an identifier, use the -source 1.3 command line flag to javac

Back 33

keyword or an identifier

Front 34

assertions are disabled at runtime by default. to enable them

Back 34

use a command-line flag -ea or -enableassertions

Front 35

selectively disable assertions by using the

Back 35

-da or -disableassertions flag

Front 36

if you enable or disable assertions using the flag ___, you're enabling or disabling assertions in general. you can combine enabling and disabling switches to have assertions enabled for some classes and/or packages, but not others

Back 36

without any arguments

Front 37

you can/can't enable and disable assertions on a package-by-package basis, and any package you specify also includes any subpackages (packages further down the directory hierarchy)

Back 37

can

Front 38

do not use assertions to validate

Back 38

arguments to public methods

Front 39

do not use assert expressions that ___. assertions aren't guaranteed to always run, and you don't want behavior that changes depending on whether assertions are enabled

Back 39

cause side effects

Front 40

do use assertions-even in public methods-to validate that a particular code block will never be reached. you can use ___ ___ for code that should never be reached, so that an assertion error is thrown immediately if the assert statement is executed

Back 40

assert false;