Index

Note to the reader: Throughout this index boldfaced page numbers indicate primary discussions of a topic. Italicized page numbers indicate illustrations.

Symbols and Numbers

- operator

-- unary operator

& (ampersand; AND) operator

! (logical NOT) operator

&& (AND) conditional operator

* (asterisk)

, (comma)

. (period; dot)

; (semicolon)

for empty statement
for statement terminator

@Override annotation

[ ] (brackets)

for arrays

^ (caret) operator

|| (OR|) conditional operator

| (pipe; OR) operator

~ (bitwise NOT) operator

+ operator

++ unary operator

< (less than) operator

== (equality operator)

vs. equals() method

> (greater than) operator

0b prefix

A

abstract classes

extending and implementing
rules for
subclasses for

abstract keyword

rules for

abstract methods, integrating into concrete methods

abstract references, concrete references vs.

abstract types

design and

abstracting

data,
method code

abstraction

AbstractStringBuilder class

access modes

access modifiers

applying,
with package-aware classes,
protected,

access operator

access rights, protected keyword and

accessor methods

names for
in Point3D class

actors

add() method (ArrayList class)

addAll() method (ArrayList class)

additive operators

AND (&) operator

AND (&&) conditional operator

anonymous arrays

append() method (StringBuilder class)

args array

arraycopy() method (System class)

ArrayIndexOutOfBoundsException

catching

ArrayList API, consuming

ArrayList class

instantiating,

arrays. See also one-dimensional array

accessing component
anonymous
basics,
character, String object as,
exception from
length property of
managing string as
multi-dimensional,
declaring,
of other types,
populating
with loop,
without loop,
two-dimensional
using,

Arrays class

assignment operators

associativity, for operators

asterisk (*)

auto-boxing

automatic variables

B

bad data

bank.services package

bean model

behavior of object, methods combining with object state

binary operators, shift operators as

binarySearch() method (Arrays class)

bit fields

bitwise complement of zero

bitwise operators

NOT (~)

boilerplate

Boolean class, parameters for constructor

Boolean expression

complement of
operands

boolean variable type

default initialization value

boxing

braces

outer, for arrays

brackets ([ ])

for arrays

break statement

bug

Byte class, parameters for constructor

byte variable type

default initialization value

bytecode

C

caching

called method

calling method

interaction between variables and
passing object to called method by

capacity() method (StringBuilder class)

capacity, mutable, for ArrayList

caret (^) operator

cascading execution, in switch statement

case labels, for switch statement

case sensitivity, of methods

casting objects

casting operator

catch block

listed out of order
multiple,
possible paths

catch or declare requirement

catching checked exceptions

chaining

overloaded constructors,
overloaded methods,

char variable type

character array, String object as

Character class, parameters for constructor

charAt() method (StringBuilder class)

CharSetEncoder class

CharsetEncoder class

checked exceptions

declarations,

child class

class dependencies

.class files

overwriting at recompile

class interface

class members

classes

abstract
checked and unchecked exceptions by type,
as containers,
creating
declarations, as public
default access with members,
diagrams for visualizing
distinguishing from objects,
exam focus on
extending,
files for
final,
implementing multiple interfaces
importing,
internal and external relationships
internal context for
multiple in one file
names of
in packages,
runtime instance
simple example
structure in Java,
type system,

classpath environment variable

clear() method (ArrayList class)

clone() method (Object class)

code block separators, for while loop

code, compiling and executing

code review

CodeMalfunctionError

cohesion

cohesiveness of interface

Collection interface

collections

for-each loop for,

Collections API

comma (,)

comments, in code

communication, methods for

compiler, complaints from

compiling classes

complement of Boolean expression

composition of elements

vs. inheritance

composition relationship, vs. inheritance relationship

compound operators

concat() method (String class)

concatenation operators

concrete methods, integrating abstract into

concrete references, abstract references vs.

concrete referent

concrete type

conditional operators

constant

construction process

constructors

adding parameters to,
checked exceptions with
conditions
coupling objects with,
default,
hiding,
defining alternate,
disallowing default,
hiding
limiting access,
overloading,
chaining,
packages to encapsulate,
passing object reference into, consequences
private
requiring parameters,
side effects of

contains() method (ArrayList class)

context

non-static

copyOf() method (Arrays class)

counter variables

in for loop

coupling objects, with constructors

-cp flag, for java program

current object, this keyword to refer to

D

data. See also encapsulating data

abstracting,
bad
exposing through methods,
hiding,
and internal context for class
passing among methods,
passing as parameters
saving at thrown exception

data types. See types

declarations

arrays
multi-dimensional,
one-dimensional,
checked exception,
class ineligible for subclass
fields
location in class structure
private vs. public
static,
methods
static,
packages,
and exposing data
variables,

decrementing variables

default access mode

default access modifier

default constructor

disallowing,
hiding,

default initialization

overriding value,
values by type
of variables,

default package, source-code file as

delete() method (StringBuilder class)

dependencies

diagrams, for visualizing classes

directories, for packages

do/while loops

documentation

online

dot (. period)

Double class, parameters for constructor

double variable type

default initialization value

E

Eclipse

else statement

email server, well-known port for

encapsulating data

constructors
packages for encapsulating constructors,

ensureCapacity() method (ArrayList class)

enum type

for loops for

enumeration

Wikipedia on

equality contract, final keyword and

equality in Java

objects,

equality operator (==)

equals() method (Object class)

vs. == (equality operator)
rules for overriding

Error class

errors in Java

compiled packages and
invalid method declaration
message on non-static method
missing return statement
Parent() has private access in Parent

Exception class

exceptions

from arrays
basics,
calling methods that throw,
code style
declarations,
expense to compute object code
handling, 263–
InterruptedException
role of,
try-catch block for,
types,
recognizing,

eXclusive OR (XOR) operator

execution, recover and continue

explicit cast

expressions

to initialize variables
operands in

expressive syntax

expressiveness

extending

classes,
parent class,

extends keyword

F

factory method

Factory Pattern

failure, planning for

false value

fields

declarations
location in class structure
private vs. public
static,
with default access
in interface definition

FileNotFoundException

files, for classes

fill() method (Arrays class)

final classes

final keyword

and constructors
equality contract and,
for methods
to prevent inheritance
removing,

final method, in Template Method pattern

finalize() method (Object class)

finally block

flags

Float class, parameters for constructor

float variable type

default initialization value

floating-point values

for each loops

with collections,
using,

for loops

for enum type
flow diagram,
unreachable code in
using,

FQPN (fully qualified package name), for class

FreeCopy class

functional method

names for
varargs feature for

functions. See also methods

future-proofing

G

garbage collection

generalization

of method code

generics

get methods

getConnected() method

getFile() method

getInstance() method

goto statement

greater than (>) operator

GridBagConstraints class

grouping rules

H

has-a relationship

hasNext() method (Iterator interface)

"Hello World" example

Helper class

hiding

constructors
data,
and internal context for class
default constructor,

I

IDEs (integrated development environments)

if/else statement

if statement

IllegalArgumentException class

immutability, of String referent

implementation details

implementation, of interface methods

implicit casting

import statements

importing Java classes, 10–

incrementing variables

indented code

index, for array

indexed elements, in arrays

infinite loop

avoiding,
for statement version

infix notation

inheritance

broken relationship
vs. composition
final keyword to prevent
how it works,
Java’s single parent rule,
relationship, vs. composition relationship
UML for

inherited code

inherited method

modifying or replacing,
signature
visibility of

initialization

other objects for,
overriding default value,
partial
variables,
default,

inner classes

inner loop

insert() method (StringBuilder class)

instance variable, declaring

instanceof keyword

instantiating

ArrayList class,
multi-dimensional array,
one-dimensional array,

int variable type

default initialization value

Integer class, parameters for constructor

integer values, primitives for

integrated development environments (IDEs)

Intellil, IDEA

interfaces

method returning
wrapping methods

intern pool

InternalError class

InterruptedException

InterruptionException object

invalid method declaration error

inversion-of-control principle

IOException class

is-a relationship

isEmpty() method (ArrayList class)

isJavaIdentiferPart() method

isJavaIdentifierStart() method

iterability of Collections types

iterating over multiple data. See also while loops

for varargs feature

Iterator interface

iterator() method (Collections)

J

Java

class structure,
terminology

Java compiler

Java core libraries, exam focus on

Java Development Kit (JDK)

.java file extension

Java file, order of statements

Java Language Specification (JLS)

Java SE 7 version

features for writing exception code

Java Virtual Machine (JVM)

configuration for finding files

java.awt package, GridBagConstraints class

JavaBeans Component API

java.beans package

java.io.Externalizable interface

java.io.FileNotFoundException class

java.io.PrintStream object

java.io.Serializable class

java.io.Serializable interface

java.lang package

java.lang.Math class

java.lang.Object class

methods

java.lang.SecurityManager class

java.lang.String class

java.lang.Throwable class

java.nio.file.Files class

java.util package, . See also ArrayList class

Collections types in

java.util.Collections class

JDK (Java Development Kit)

JLS (Java Language Specification)

JVM. See Java Virtual Machine (JVM)

K

keywords in Java

for primitives

L

labeled statements

labels, for switch statement

LawnServices interface

length() method (StringBuilder class)

length property of arrays

and for statement

less than (<) operator

life cycle, of Java objects

lifetime

of referent
of variable

LinkageError

List interface, for ArrayList class

lists, arrays and

local variables

logical operators

NOT (!)

Long class, parameters for constructor

long variable type

default initialization value

loops

avoiding useless,
comparing constructs,
continue statement,
do/while,
for,
flow diagram,
using,
for each,
using,
infinite, –102
avoiding,
for statement version
labeled statements,
nested,
populating array with,
while,

loose coupling

M

main() method

maintainability

marker interface

members of class

memory management

message

in Throwable object

method interface

methods

checked exceptions with
choosing which to make public,
communication by
declarations
static,
with default access
designing,
parameters,
distinguishing from data in class,
exposing data through,
final keyword for
generalizing code
inducing side effects,
inherited
modifying or replacing,
signature
visibility
integrating abstract into concrete
in interfaces
wrapping
modifiers,
choosing,
names for,
namespace for
overloading,
allowing for variable number of parameters,
chaining,
support of multiple parameter lists,
overriding,
passing data among,
passing whole arrays as parameters
prohibiting override,
return types,
signature of,
parameters and
signatures,
syntax
visibility

missing return statement error

multi-dimensional array

declaring,
instantiating and using,

multiplicative operators

MultTable class, offset technique in

mutability

mutator methods

names for

N

names

of classes
for methods,
methods and classes
in object-oriented languages

namespace

naming scheme, in bean model

native keyword

and constructors

navigability in UML

NegativeArraySizeException class

nested braces, for component arrays

nested logic approach

nested loop

NetBeans

new keyword

compiler assumptions and
no-arg constructor called with

next() method (Iterator interface)

no-arg constructor

no-op statement

non-public classes

non-public constructors, reasons for use

non-static context

NOT operators

null keyword

assigning to array
method returning

NumberFormatException object

O

object equality, vs. object state

object fields, reading and writing

object-oriented languages

design benefits
names in

object references

narrowing scope for
passing into constructor, consequences
vs. primitives,
printing
returning,

object state, vs. object equality

objects

casting,
constructors for,
creating,
creating singleton,
direct field access in,
distinguishing from classes,
equality,
managing complex assembly process
organizing by type,
serializing
using other, for initialization,

one-dimensional array

declarations,
instantiating,

operands

operations

operators in Java

assignment,
bitwise,
conditional,
equality,
logical,
multiplicative and additive,
parentheses to control,
postfix/prefix operators,
precedence and associativity,
relational,
separators,
shift,
types,
unary,

OR (||) conditional operator

OR (|; pipe) operator

Oracle Certified Associate

exam
objectives map,
test cases

order of parameters, overloading by

order of precedence

out (output stream)

out-of-bounds errors

outer braces, for arrays

outer loop

OutOfMemoryError class

overloading

constructors,
chaining,
methods,
allowing for variable number of parameters,
chaining,
signature and
support of multiple parameter lists,
operators, interpreting,

@Override annotation

overriding

default initialization value,
methods,
prohibiting,

P

package-aware classes, access modifiers with

package-private

packages

adding test code inside
classes in,
declarations,
and exposing data
to encapsulate constructors,
shared scope

parameter list, for main() method

parameters

adding to constructors,
allowing for variable number,
enum element as
in method design,
overloading based on
passing data as
passing to parent constructor,
passing whole arrays as
primitives as,
reference,
requiring,
validating incoming,

parent class

extending,
Java’s rule for single,

parent constructor

choosing,
passing parameters to,

parent-first construction model

Parent() has private access in Parent error

parent method, adding to code from

parentheses

to control operators,

parseArray() method

partial initialization

pass-by-value

period (. dot)

pipe (|; OR) operator

pixel

planning

for failure
for variation,

Point3D class

code to store and modify one coordinate
naming scheme
without methods

polymorphic behavior

method names to effect,

populating array

with loops,
without loops,

possible loss of precision

postfix notation

postfix/prefix operators

precedence, for operators

precision

degree needed
possible loss of

primitives

vs. object references,
as parameters,

printing, object references

println() method, for observing change

printStackTrace() method

private access modifier

private constructors

private fields, vs. public

private members of parent class

procedural methods

names for

procedures. See also methods

program, goals

program state

properties

data as list of

protected access modifier

protected keyword, access rights and

proxy construction class

pseudocode

public classes, need for

public constructor

public fields, vs. private

public keyword

public method

choosing,

pure type

R

realization, in UML

refactoring

reference

abstract vs. concrete,
code belonging to

reference parameters

referent

constructor return of
lifetime of
testing

registers

regression

relational operators

reading every test using

releasing system resources

remove() method (ArrayList class)

removeRange() method (ArrayList class)

replace() method (String class)

return keyword

return types, for methods

returned value

object references as,

reverse() method (StringBuilder class)

Reverse Polish Notation

robust program, response to exceptions

run() method

RuntimeException class

S

scope

for try block
of variables,
minimizing/localizing,

scope-based breaks

SecurityException class

semicolon (;)

for empty statement
for statement terminator

separators

sequence diagram in UML

Serializable interface

serializing object

service loop

service time

set methods

justifying
in Point3D class

setCharAt() method (StringBuilder class)

setObject() method

sets

shift operators

shifting operators

short-circuit operators

Short class, parameters for constructor

short variable type

default initialization value

side effects of methods, inducing

signature

of main() method
of methods,
inherited
parameters and

Simple Mail Transfer Protocol (SMTP)

size() method (ArrayList class)

sleep() method (Thread class)

sort() method (Arrays class)

spaghetti code

specializing

stack trace

StackOverflowError class

state of object

methods combining with behavior of object
void and

statements, semicolon as terminator

static keyword

and constructors
for methods
in private constructor
objects calling methods

static members

step operation

reviewing method call in

strictfp keyword

and constructors

String class

as final
immutability
vs. StringBuilder class
wrapping method

String object, as character array

String referent, immutability of

String type

StringBuilder class

constructing object
vs. String class
testing default constructor

strings, creating and manipulating

“stubbing out” abstract methods

subclasses

for abstract class
declaring class ineligible
inheritance of methods
preventing,

subpackages

substring() method (StringBuilder class)

super keyword

to access parent method

switch statement

case labels for
enum type as argument

synchronized keyword

and constructors

sysPrint() method

system configuration

system resources

finally block to release or close
releasing

System.arraycopy() method

System.err.print() method

System.exit() method

System.out.println() method

T

tagging interface

Template Method pattern

applying,
enforcing,

temporary variable

terminal condition for loop, managing

ternary operator

test code

adding inside package

testing, changing condition for while loop

TestResources object

third-party code packages

this keyword

for chaining constructor calls

Thread class, sleep() method

three-dimensional array, declaring

throw statement

Throwable class

relationships,

throwing exception

throws keyword

tight coupling

toArray() method (ArrayList class)

toCharArray() method

tokens, as operators

toLowerCase() method (String class)

traversing collection

trimToSize() method (ArrayList class)

trimToSize() method (StringBuilder class)

true value

truth functions

try-catch block

catching exception,
finally block,
handling unchecked exceptions,
multiple catch blocks,
throwing exception,
ways to leave

two-dimensional array, declaring

two’s complement scheme

type-safe language, Java as

type safety

type system

of classes,

types

for arrays
default value
enum,
exceptions,
for fields
organizing objects by,
restricting range,
for variables

U

unary operators

unchecked exceptions

handling,

Unicode character set

Java support for

Unified Modeling Language (UML)

applying
inheritance
public and private members in diagram
realization in
sequence diagram

unit testing

UnknownError class

UnknownHostException class

unreachable code, in for loops

UnsupportedOperationException class

use case

user

exception from bad input by
informing of exception

utility class

utility methods

V

validating incoming parameters

varargs feature

variable scope

variable stack

variables

for counters
declaring and initializing,
default initialization,
vs. fields
incrementing and decrementing
interaction between callers and
minimizing/localizing scope,
references as
scope expiration and
temporary
in try block

variation, planning for

-verbose flag

-version flag

VirtualMachineError class

visibility

of inherited method
of methods
reducing

void keyword

W

while loops

choosing useful test,

white space

wildcard, for importing all classes from package

wrapper classes

writing code, indented format

X

XOR (eXclusive OR) operator

Z

zero, bitwise complement of

zero elements, array with

..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.
Reset
3.141.200.3