preface

vii

computer systems

(56)

introduction

(8)

basic computer processing

(1)

software categories

(1)

digital computers

(3)

binary numbers

(3)

hardware components

(8)

computer architecture

(2)

input/output devices

(1)

main memory and secondary memory

(4)

the central processing unit

(2)

networks

(6)

network connections

(1)

local-area networks and wide-area networks

(1)

the Internet

(1)

the World Wide Web

(2)

Uniform Resource Locators

(1)

the Internet vs. the World Wide Web

(1)

programming

(10)

problem solving

(1)

the Java programming language

(1)

a Java program

(1)

comments

(2)

identifiers and reserved words

(3)

white space

(1)

programming languages

(8)

programming language levels

(2)

compilers and interpreters

(2)

syntax and semantics

(1)

errors

(1)

language evolution

(1)

graphics

(15)

coordinate systems

(1)

representing color

(14)

objects and primitive data

(64)

an introduction to objects

(2)

using objects

(3)

the print and println methods

(2)

abstraction

(1)

string literals

(4)

string concatenation

(3)

escape sequences

(1)

variables and assignment

(4)

variables

(2)

the assignment statement

(2)

constants

(1)

primitive data types

(3)

integers and floating points

(1)

booleans

(1)

characters

(1)

arithmetic expressions

(5)

operator precedence

(2)

data conversion

(2)

creating objects

(6)

the String class

(2)

wrapper classes

(3)

class libraries and packages

(6)

the import declaration

(2)

the Random class

(2)

invoking class methods

(5)

the Math class

(1)

the Keyboard class

(5)

formatting output

(4)

the NumberFormat class

(2)

the DecimalFormat class

(2)

an introduction to applets

100

(3)

executing applets using the Web

102

(1)

drawing shapes

103

(18)

the Graphics class

103

(2)

the Color class

105

(16)

program statements

121

(68)

program development

122

(2)

control flow

124

(1)

the if statement

125

(10)

equality and relational operators

127

(1)

the if--else statement

128

(3)

using block statements

131

(2)

nested if statements

133

(2)

boolean expressions revisited

135

(5)

logical operators

135

(3)

comparing characters and strings

138

(1)

comparing floating point values

139

(1)

more operators

140

(2)

increment and decrement operators

140

(1)

assignment operators

140

(2)

the while statement

142

(14)

infinite loops

146

(3)

nested loops

149

(4)

the StringTokenizer class

153

(3)

the for statement

156

(6)

comparing loops

160

(2)

program development revisited

162

(4)

bumper cars case study: introduction

166

(2)

requirements

167

(1)

drawing using conditionals and loops

168

(21)

writing classes

189

(58)

objects revisited

190

(2)

classes

191

(1)

anatomy of a class

192

(9)

instance data

196

(2)

encapsulation and visibility modifiers

198

(3)

anatomy of a method

201

(9)

the return statement

206

(1)

parameters

207

(2)

constructors

209

(1)

local data

209

(1)

method overloading

210

(4)

method decomposition

214

(5)

object relationships

219

(10)

association

219

(1)

association between objects of the same class

220

(5)

aggregation

225

(4)

bumper cars case study: design

229

(2)

program flow

230

(1)

applet methods

231

(1)

graphical objects

232

(15)

enhancing classes

247

(50)

references revisited

248

(8)

the null reference

248

(1)

the this reference

249

(1)

aliases

250

(2)

passing objects as parameters

252

(4)

the static modifier

256

(5)

static variables

257

(1)

static methods

257

(4)

exceptions

261

(2)

exception messages

261

(2)

throwing exceptions

263

(1)

interfaces

263

(8)

the Comparable interface

268

(1)

the List interface

269

(1)

the Iterator and ListIterator interfaces

270

(1)

designing classes

271

(2)

bumper cars case study: drivers

273

(3)

nested classes

276

(1)

inner classes

277

(1)

dialog boxes

277

(3)

graphical user interfaces

280

(17)

essential GUI elements

280

(1)

creating GUIs

281

(3)

GUI applications

284

(13)

arrays

297

(84)

arrays

298

(10)

array indexing

298

(1)

declaring and using arrays

299

(8)

initializer lists

307

(1)

arrays as parameters

307

(1)

arrays of objects

308

(9)

arrays of string objects

309

(1)

command-line arguments

309

(3)

filling arrays of objects

312

(5)

searching

317

(5)

sorting

322

(8)

selection sort

322

(4)

insertion sort

326

(1)

sorting an array of objects

327

(3)

comparing sorts

330

(2)

hashing

332

(1)

two-dimensional arrays

333

(4)

the ArrayList class

337

(5)

using a ListIterator

340

(1)

ArrayList efficiency

340

(2)

bumper cars case study: the arena

342

(16)

an alternate arena

344

(1)

first-stage implementation

345

(6)

managing the simulation

351

(7)

polygons and polylines

358

(3)

the Polygon class

360

(1)

other button components

361

(20)

check boxes

362

(3)

radio buttons

365

(16)

inheritance

381

(72)

creating subclasses

382

(8)

derived classes

382

(4)

the super reference

386

(2)

multiple inheritance

388

(2)

overriding methods

390

(1)

class hierarchies

391

(14)

the Object class

394

(5)

abstract classes

399

(6)

indirect use of class members

405

(4)

polymorphism

409

(10)

references and class hierarchies

409

(1)

polymorphism and inheritance

410

(9)

interfaces

419

(4)

polymorphism with interfaces

419

(4)

bumper cars case study: the driver program

423

(5)

inheritance and GUIs

428

(3)

applets

428

(1)

the component class hierarchy

429

(2)

mouse events

431

(22)

extending event adapter classes

439

(14)

recursion

453

(60)

recursive thinking

454

(2)

infinite recursion

455

(1)

recursion in math

455

(1)

recursive programming

456

(4)

recursion vs. iteration

459

(1)

direct vs. indirect recursion

459

(1)

using recursion

460

(9)

solving a maze

460

(5)

the Towers of Hanoi

465

(4)

recursion in sorting

469

(8)

merge sort

470

(5)

quick sort

475

(2)

bumper cars case study: putting it all together

477

(16)

testing

492

(1)

extensions

492

(1)

recursion in graphics

493

(20)

tiled pictures

493

(3)

fractals

496

(17)

data structures

513

(30)

collections

514

(1)

separating interface from implementation

514

(1)

Java API collection classes

514

(1)

representing data structures

515

(11)

dynamic structures

515

(3)

managing linked lists

518

(1)

inserting nodes

518

(1)

deleting nodes

519

(1)

a dynamically linked list example

520

(4)

other dynamic list representations

524

(1)

LinkedList

525

(1)

queues and stacks

526

(17)

queues

526

(2)

stacks

528

(15)

data structures II

543

(42)

sets and maps

544

(1)

trees

545

(15)

tree traversal

550

(2)

binary search trees

552

(6)

TreeSet and TreeMap

558

(2)

heaps

560

(6)

heapsort

565

(1)

implementing heaps

565

(1)

Amazon no longer offers textbook rentals. We do!

Amazon no longer offers textbook rentals. We do!

We're the #1 textbook rental company. Let us show you why.

Java Software Solutions, AP Version

9780201882599

0201882590

Supplemental Materials

Summary

Table of Contents

Supplemental Materials

Rewards Program