Java Software Solutions

by Lewis, John; Loftus, William

• ISBN13: 9780201725971
• ISBN10: 0201725975
• Edition: 2nd
• Format: Paperback
• Copyright: 2000-11-01
• Publisher: Addison-Wesley

Summary

Embracing in full the new features of the Java 2 platform as they apply to CS1 topics, this leading textbook continues to teach beginning programs how to design and implement high-quality object-oriented software. New in the second edition is a chapter entitled "Input and Output" (Ch. 7), which explains the class library used earlier in the text and explores other I/O issues such as streams, file I/O, and network-based I/O. Applets and applications are intertwined throughout the book to demonstrate computing concepts-applets, introduced in Ch. 2, build on the excitement of the web, while applications allow students to gain a clear understanding of programming concepts. Lewis and Loftus have expanded their coverage of classes and objects with this edition (introduced in Ch. 4) to provide more in-depth discussion of methods and parameter passing, method and static variables, and method overloading. Discussion of Swing architecture and components is also new to this edition, as well as the inclusion of new Collection classes. The Update to the second edition has been published to provide readers with additional resources to enhance their learning. It includes a CD-ROM with various development environments, the textbook example code, and the presentation slides from the book. The typeface for of some of the code has been redesigned to make it more legible. Lastly, the update includes all corrections that have been discovered since the second edition's publication. The main content and flow of the update will remain as it is.

Table of Contents

Preface	v
Computer Systems	1	(50)
Introduction	2	(7)
Basic Computer Processing	2	(1)
Software Categories	3	(2)
Digital Computers	5	(2)
Binary Numbers	7	(2)
Hardware Components	9	(7)
Computer Architecture	9	(2)
Input/Output Devices	11	(1)
Main and Secondary Memory	11	(4)
The Central Processing Unit	15	(1)
Networks	16	(7)
Network Connections	17	(1)
Local-Area and Wide-Area Networks	18	(1)
The Internet	19	(2)
The World Wide Web	21	(1)
Uniform Resource Locators	22	(1)
Programming	23	(9)
Problem Solving	23	(1)
The Java Programming Language	24	(1)
A Java Program	25	(2)
Comments	27	(2)
Identifiers and Reserved Words	29	(2)
White Space	31	(1)
Programming Languages	32	(8)
Programming Language Levels	34	(2)
Compilers and Interpreters	36	(1)
Syntax and Semantics	37	(1)
Errors	38	(2)
Language Evolution	40	(1)
Graphics	40	(11)
Coordinate Systems	41	(1)
Representing Color	42	(9)
Objects and Primitive Data	51	(58)
Introduction to Objects	52	(3)
The print and printing Methods	52	(2)
Abstraction	54	(1)
String Literals	55	(5)
String Concatenation	55	(2)
Escape Sequences	57	(3)
Variables and Assignment	60	(4)
Variables	60	(2)
The Assignment Statement	62	(1)
Constants	63	(1)
Primitive Data Tapes and Expressions	64	(10)
Integers and Floating Points	64	(2)
Characters	66	(1)
Booleans	67	(1)
Arithmetic Expressions	67	(1)
Operator Precedence	68	(2)
Data Conversion	70	(4)
Creating Objects	74	(4)
The string Class	75	(3)
Class Libraries and Packages	78	(5)
The import Declaration	79	(2)
The Random Class	81	(2)
Invoking Class Methods	83	(5)
The Math Class	83	(1)
The Keyboard Class	83	(5)
Formatting Output	88	(4)
The NumberFormat Class	88	(2)
The DecimalFormat Class	90	(2)
An Introduction to Applets	92	(3)
Executing Applets using the Web	94	(1)
Drawing Shapes	95	(14)
The Graphics Class	95	(3)
The Color Class	98	(11)
Program Statements	109	(66)
Control Flow	110	(1)
The if Statement	111	(8)
Equality and Relational Operators	113	(1)
The if-else Statement	114	(1)
Using Block Statements	115	(1)
Nested if Statements	115	(4)
The switch Statement	119	(4)
Boolean Expressions Revisited	123	(4)
Logical Operators	123	(2)
Comparing Characters and Strings	125	(1)
Comparing Floats	126	(1)
More Operators	127	(4)
Increment and Decrement Operators	127	(1)
Assignment Operators	128	(2)
The Conditional Operator	130	(1)
The while Statement	131	(10)
Infinite Loops	137	(1)
Nested Loops	137	(1)
Other Loop Controls	137	(4)
The do Statement	141	(4)
The for Statement	145	(6)
Developing Programs	151	(6)
Development Stages	151	(6)
Drawing using Conditionals and Loops	157	(18)
Writing Classes	175	(46)
Objects Revisited	176	(2)
Classes	177	(1)
Anatomy of a Class	178	(8)
Instance Data	178	(6)
Encapsulation and Visibility Modifiers	184	(2)
Anatomy of a Method	186	(9)
The return Statement	192	(1)
Parameters	193	(1)
Constructors	194	(1)
Local Data and Scope	194	(1)
Object Relationships	195	(6)
The has-a Relationship	195	(1)
Interaction Between Objects of the Same Class	195	(6)
Method Overloading	201	(5)
Method Decomposition	206	(5)
The StringTokenizer Class	206	(5)
Applet Methods	211	(1)
Graphical Objects	212	(9)
Enhancing Classes	221	(46)
Differences Revisited	222	(9)
The null Reference	222	(1)
Aliases	223	(2)
Garbage Collection	225	(1)
Passing Objects as Parameters	226	(4)
The this Reference	230	(1)
The static Modifier	231	(3)
Static Variables	231	(1)
Static Methods	232	(2)
Nested Classes	234	(2)
Inner Classes	235	(1)
Interfaces	236	(7)
Polymorphism via Interfaces	239	(3)
The comparable Interface	242	(1)
The Iterator Interface	242	(1)
Events and listeners	243	(13)
Events	243	(1)
Listener Interfaces	244	(12)
Animations	256	(11)
The Timer Class	256	(11)
Arrays and Vectors	267	(54)
Arrays	268	(10)
Array Indexing	268	(1)
Declaring and Using Arrays	269	(7)
Alternate Array Syntax	276	(1)
Initializer Lists	277	(1)
Arrays as Parameters	277	(1)
Arrays of Objects	278	(9)
Arrays of String Objects	279	(1)
Command-Line Arguments	279	(3)
Creating Object-Array Elements	282	(5)
Sorting	287	(10)
Selection Sort	287	(5)
Insertion Sort	292	(1)
Sorting an Array of Objects	293	(3)
Comparing Sorts	296	(1)
Two-Dimensional Arrays	297	(5)
Multidimensional Arrays	301	(1)
The Vector Class	302	(4)
Vector Efficiency	305	(1)
Arrays and Graphics	306	(15)
Polygons and Polylines	306	(3)
The Polygon Class	309	(1)
Saving the State of a Drawing	310	(11)
Inheritance	321	(56)
Creating Subclasses	322	(9)
Derived Classes	322	(4)
The protected Modifier	326	(1)
The super Reference	327	(3)
Multiple Inheritance	330	(1)
Overriding Methods	331	(4)
Shadowing Variables	333	(2)
Class Hierarchies	335	(8)
The Object Class	336	(2)
Abstract Classes	338	(5)
Polymorphism via Inheritance	343	(11)
References and Class Hierarchies	343	(11)
Indirect Use of Noninherited Members	354	(4)
Interface Hierarchies	358	(1)
Inheritance and Graphics	358	(4)
Applets Revisited	358	(1)
Extending Event Adapter Classes	359	(3)
GUI Components	362	(15)
The component Class Hierarchy	365	(12)
Exceptions and I/O Streams	377	(32)
Exceptions	378	(12)
Exception Messages	378	(1)
The try Statement	379	(4)
The finally Clause	383	(1)
Exception Propagation	383	(4)
The Exception Class Hierarchy	387	(3)
Checked and Unchecked Exceptions	390	(1)
Input/Output Streams	390	(4)
Character Streams vs. Byte Streams	392	(1)
Data Streams vs. Processing Streams	392	(1)
The IOException Class	392	(2)
Standard I/O	394	(2)
The Keyboard Class Revisited	395	(1)
Text files	396	(7)
Reading Text Files	396	(5)
Writing Text Files	401	(2)
Object Serialization	403	(6)
The transient Modifier	404	(5)
Graphical User Interfaces	409	(30)
Java GUI Overview	410	(1)
AWT and Swing	410	(1)
Containers	411	(3)
Graphics in Applications	411	(3)
Components	414	(15)
Labels and Image Icons	415	(3)
Buttons	418	(6)
Combo Boxes	424	(5)
Layout Managers	429	(4)
Flow Layout	430	(1)
Border Layout	430	(1)
Box Layout	431	(2)
Special Features	433	(1)
GUI Design	434	(5)
Software Engineering	439	(26)
Software Development Models	440	(5)
Software Life Cycle	440	(3)
Development Process Models	443	(1)
Iterative Processes	444	(1)
Prototypes	445	(1)
Throw-away Prototypes	446	(1)
Testing	446	(3)
Walkthroughs	447	(1)
Defect Testing	447	(2)
Evolutionary Development	449	(6)
Establish Refinement Scope	451	(1)
Identifying Classes and Objects	451	(1)
Identifying Relationships	452	(2)
Detailed Design	454	(1)
Implementation	454	(1)
Unit and Integration Testing	454	(1)
The PaintBox Object	455	(10)
Recursion	465	(32)
Recursive Thinking	466	(2)
Infinite Recursion	467	(1)
Recursion in Math	467	(1)
Recursive Programming	468	(4)
Recursion vs. Iteration	470	(1)
Direct vs. Indirect Recursion	471	(1)
Using Recursion	472	(10)
Traversing a Maze	472	(5)
The Towers of Hanoi	477	(5)
Recursion in Graphics	482	(15)
Mirrored Pictures	482	(3)
Fractals	485	(12)
Data Structures	497	(20)
Collections	498	(1)
Separating Interface from Implementation	498	(1)
Implementing Data Structures	498	(8)
Dynamic Structures	499	(1)
A Dynamically Linked List	499	(5)
Other Dynamic List Implementations	504	(2)
Classic Data Structures	506	(4)
Queues	506	(1)
Stacks	507	(1)
Example: Message Decoding	508	(2)
Collection Classes	510	(7)
Appendix A Glossary	517	(20)
Appendix B Number Systems	537	(8)
Appendix C The Unicode Character Set	545	(4)
Appendix D Java Operators	549	(4)
Appendix E Java Bitwise Operators	553	(4)
Appendix F Java Modifiers	557	(4)
Appendix G Java Coding Guidelines	561	(6)
Appendix H Review Checklist	567	(4)
Appendix I Comparing Java to C++	571	(6)
Appendix J An HTML Tutorial	577	(20)
Appendix K Java Exceptions and Errors	597	(6)
Appendix L Java Syntax	603	(14)
Appendix M The Java Class Library	617	(150)
Index	767