Java Software Solutions

by Lewis, John; Loftus, William

• ISBN13: 9780201781298
• ISBN10: 0201781298
• Additional ISBN(s): 9780201750522, 9780321245830
• Edition: 3rd
• Format: Paperback
• Copyright: 2002-07-01
• Publisher: Addison-Wesley
• More Book Details
• Purchase Benefits

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