CART

(0) items

Java Software Solutions : Foundations of Program Design,9780201781298
This item qualifies for
FREE SHIPPING!

FREE SHIPPING OVER $59!

Your order must be $59 or more, you must select US Postal Service Shipping as your shipping preference, and the "Group my items into as few shipments as possible" option when you place your order.

Bulk sales, PO's, Marketplace Items, eBooks, Apparel, and DVDs not included.

Java Software Solutions : Foundations of Program Design

by ;
Edition:
3rd
ISBN13:

9780201781298

ISBN10:
0201781298
Media:
Paperback
Pub. Date:
7/1/2002
Publisher(s):
Pearson College Div
List Price: $88.00

Buy Used Textbook

(Recommended)
In Stock Usually Ships in 24-48 Hours
$61.60

Rent Textbook

We're Sorry
Sold Out

eTextbook

We're Sorry
Not Available

New Textbook

We're Sorry
Sold Out

More New and Used
from Private Sellers
Starting at $0.01

Questions About This Book?

What version or edition is this?
This is the 3rd edition with a publication date of 7/1/2002.
What is included with this book?
  • The Used copy of this book is not guaranteed to inclue any supplemental materials. Typically, only the book itself is included.

Related Products


  • Java Software Solutions
    Java Software Solutions
  • Java Software Solutions (Java 5.0 version): Foundations of Program Design
    Java Software Solutions (Java 5.0 version): Foundations of Program Design
  • Java Software Solutions : Foundations of Program Design
    Java Software Solutions : Foundations of Program Design
  • Java Software Solutions : Foundations of Program Design
    Java Software Solutions : Foundations of Program Design
  • Java Software Solutions : Foundations of Program Design
    Java Software Solutions : Foundations of Program Design
  • Java Software Solutions : Foundations of Program Design
    Java Software Solutions : Foundations of Program Design
  • Java Software Solutions : Foundations of Program Design
    Java Software Solutions : Foundations of Program Design
  • Java Software Solutions : Foundations of Program Design, Updated
    Java Software Solutions : Foundations of Program Design, Updated
  • Java Software Solutions Foundations of Program Design plus MyProgrammingLab with Pearson eText -- Access Card
    Java Software Solutions Foundations of Program Design plus MyProgrammingLab with Pearson eText -- Access Card
  • Java Software Solutions with MyProgrammingLab -- Access Card Package
    Java Software Solutions with MyProgrammingLab -- Access Card Package
  • Lab Manual for Java Software Solutions : Foundations of Program Design
    Lab Manual for Java Software Solutions : Foundations of Program Design




Summary

This best-selling text by Lewis and Loftus provides an introduction to both the Java programming language and the techniques for writing high-quality programs. This book provides an object-oriented approach that naturally progresses in a way that beginning programmers easily understand by first using objects, then writing clases. The book is also known for providing an introduction to programming practices that leads to well-designed software solutions. The use of graphical user interfaces and event processing is covered in optional, self-contained Graphics Track sections at the end of each chapter.

Table of Contents

Preface v
computer systems
1(60)
introduction
2(8)
basic computer processing
2(1)
software categories
3(2)
digital computers
5(3)
binary numbers
8(2)
hardware components
10(9)
computer architecture
11(2)
input/output devices
13(1)
main memory and secondary memory
13(5)
the central processing unit
18(1)
networks
19(8)
network connections
20(1)
local-area networks and wide-area networks
21(2)
the Internet
23(1)
the World Wide Web
24(1)
Uniform Resource Locators
25(2)
the Internet vs. the World Wide Web
27(1)
programming
27(11)
problem solving
27(2)
the Java programming language
29(1)
a Java program
30(2)
comments
32(2)
identifiers and reserved words
34(2)
white space
36(2)
programming languages
38(9)
programming language levels
39(2)
compilers and interpreters
41(3)
syntax and semantics
44(1)
errors
45(1)
language evolution
46(1)
graphics
47(14)
coordinate systems
48(1)
representing color
49(12)
objects and primitive data
61(68)
an introduction to objects
62(2)
using objects
64(3)
the print and println methods
64(2)
abstraction
66(1)
string literals
67(5)
string concatenation
67(2)
escape sequences
69(3)
variables and assignment
72(4)
variables
72(1)
the assignment statement
73(2)
constants
75(1)
primitive data types and expressions
76(4)
integers and floating points
76(2)
characters
78(2)
booleans
80(1)
arithmetic expressions
80(7)
operator precedence
81(3)
data conversion
84(3)
creating objects
87(4)
the string class
88(3)
class libraries and packages
91(7)
the import declaration
92(3)
the Random class
95(3)
invoking class methods
98(5)
the Math class
98(1)
the Keyboard class
98(5)
formatting output
103(3)
the NumberFormat class
103(2)
the DecimalFormat class
105(1)
an introduction to applets
106(5)
executing applets using the Web
110(1)
drawing shapes
111(18)
the Graphics class
111(3)
the color class
114(15)
program statements
129(80)
program development
130(2)
control flow
132(1)
the if statement
133(11)
equality and relational operators
136(1)
the if-else statement
137(3)
using block statements
140(2)
nested if statements
142(2)
the switch statement
144(4)
boolean expressions revisited
148(5)
logical operators
148(3)
comparing characters and strings
151(2)
comparing floats
153(1)
more operators
153(4)
increment and decrement operators
153(2)
assignment operators
155(1)
the conditional operator
156(1)
the while statement
157(16)
infinite loops
162(4)
nested loops
166(3)
the StringTokenizer Class
169(2)
other loop controls
171(2)
the do statement
173(4)
the for statement
177(6)
comparing loops
181(2)
program development revisited
183(5)
drawing using conditionals and loops
188(21)
writing classes
209(60)
objects revisited
210(2)
classes
211(1)
anatomy of a class
212(11)
instance data
216(2)
UML diagrams
218(2)
encapsulation and visibility modifiers
220(3)
anatomy of a method
223(10)
the return statement
225(6)
parameters
231(1)
constructors
232(1)
local data
233(1)
method overloading
233(2)
method decomposition
235(8)
object relationships
243(12)
association
243(1)
association between objects of the same class
244(6)
aggregation
250(5)
applet methods
255(1)
graphical objects
256(13)
enhancing classes
269(50)
references revisited
270(12)
the null reference
270(1)
the this reference
271(1)
aliases
272(3)
garbage collection
275(1)
passing objects as parameters
276(6)
the static modifier
282(1)
static variables
282(1)
static methods
282(1)
wrapper classes
283(4)
keyboard input revisited
287(3)
nested classes
290(4)
inner classes
290(4)
interfaces
294(7)
the Comparable interface
300(1)
the Iterator interface
300(1)
dialog boxes
301(3)
graphical user interfaces
304(15)
essential GUI elements
304(1)
creating GUIs
305(3)
GUI applications
308(11)
arrays
319(62)
arrays
320(11)
array indexing
320(1)
declaring and using arrays
321(7)
alternate array syntax
328(1)
initializer lists
329(1)
arrays as parameters
330(1)
arrays of objects
331(8)
arrays of string objects
331(2)
command-line arguments
333(1)
filing arrays of objects
333(6)
sorting
339(11)
selection sort
341(4)
insertion sort
345(1)
sorting an array of objects
346(3)
comparing sorts
349(1)
two-dimensional arrays
350(5)
multidimensional arrays
354(1)
the ArrayList class
355(4)
ArrayList efficiency
358(1)
polygons and polylines
359(4)
the Polygon class
361(2)
other button components
363(18)
check boxes
363(4)
radio buttons
367(14)
inheritance
381(66)
creating subclasses
382(9)
derived classes
382(3)
the protected modifier
385(2)
the super reference
387(2)
multiple inheritance
389(2)
overriding methods
391(3)
shadowing variables
393(1)
class hierarchies
394(8)
the object class
396(5)
abstract classes
401(1)
indirect use of class members
402(4)
polymorphism
406(14)
references and class hierarchies
407(1)
polymorphism via inheritance
408(12)
interfaces revisited
420(2)
interface hierarchies
420(1)
polymorphism via inheritance
420(2)
inheritance and GUIs
422(3)
applets revisited
423(1)
the component class hierarchy
423(2)
mouse events
425(22)
extending event adapter classes
434(13)
exceptions and i/o streams
447(60)
exceptions
448(13)
exception messages
448(2)
the try statement
450(3)
the finally clause
453(1)
exception propagation
453(1)
the exception class hierarchy
454(6)
checked and unchecked exceptions
460(1)
input/output streams
461(3)
character streams versus byte streams
462(1)
data streams versus processing streams
462(2)
the IOException class
464(1)
standard I/O
464(3)
the Keyboard class revisited
465(2)
text files
467(7)
reading text files
467(4)
writing text files
471(3)
object serialization
474(6)
the transient modifier
478(2)
files and GUIs
480(14)
file choosers
481(2)
color choosers
483(3)
image icons
486(3)
key events
489(5)
animations
494(13)
the Timer class
494(13)
graphical user interfaces
507(62)
preliminaries
508(2)
GUI review
508(1)
GUI design
509(1)
layout managers
510(16)
flow layout
513(4)
border layout
517(3)
grid layout
520(3)
box layout
523(3)
containment hierarchies
526(2)
special features
528(11)
borders
535(4)
additional components
539(20)
scroll pane
539(3)
split panes
542(1)
lists
543(5)
combo boxes
548(6)
sliders
554(5)
events revisited
559(2)
more about GUIs
561(8)
software engineering
569(34)
software development models
570(6)
software life cycle
570(3)
software development models
573(2)
iterative development
575(1)
testing
576(3)
walkthroughs
576(1)
defect testing
577(2)
prototypes
579(3)
throw-aways vs. evolutionary prototypes
580(1)
evolutionary development
580(2)
establish refinement scope
582(4)
identifying classes and objects
583(1)
identifying relationships
584(1)
detailed design
585(1)
implementation
585(1)
unit and integration testing
586(1)
the PaintBox project
586(17)
PaintBox requirements
587(2)
PaintBox architectural design
589(1)
PaintBox refinements
590(1)
PaintBox refinement #1
590(3)
PaintBox refinement #2
593(2)
remaining PaintBox refinements
595(8)
recursion
603(34)
recursive thinking
604(2)
infinite recursion
605(1)
recursion in math
605(1)
recursive programming
606(4)
recursion vs. iteration
609(1)
direct vs. indirect recursion
609(1)
using recursion
610(11)
traversing a maze
610(6)
the Towers of Hanoi
616(5)
recursion in graphics
621(16)
tiled pictures
621(3)
fractals
624(13)
data structures
637(24)
collections
638(1)
separating interface from implementation
638(1)
representing data structures
639(8)
dynamic structures
639(1)
a dynamically linked list
640(5)
other dynamic list representations
645(2)
classic data structures
647(6)
queues
647(1)
stacks
648(2)
trees and binary trees
650(1)
graphs and digraphs
651(2)
java API collection classes
653(8)
appendix A glossary 661(20)
appendix B number systems 681(8)
appendix C the unicode character set 689(4)
appendix D java operators 693(4)
appendix E java bitwise operators 697(4)
appendix F java modifiers 701(4)
appendix G java coding guidelines 705(6)
appendix H review checklist 711(4)
appendix I comparing java to C++ 715(6)
appendix J an HTML tutorial 721(20)
appendix K java exceptions and errors 741(6)
appendix L java syntax 747(14)
appendix M the java class library 761(146)
index 907


Please wait while the item is added to your cart...