CART

(0) items

Objects, Abstraction, Data Structures and Design Using Java<sup><small>TM</small></sup> Version 5.0,9780471692645
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.

Objects, Abstraction, Data Structures and Design Using JavaTM Version 5.0

by ;
ISBN13:

9780471692645

ISBN10:
0471692646
Format:
Paperback
Pub. Date:
11/1/2004
Publisher(s):
WILEY

Summary

This version of the book uses the latest Java technology, Java 2 Standard Edition Version 5.0 (J2SE V. 5.0), otherwise known as "Version 5.0."In the software engineering industry, the most important work takes place before the first line of code is written. That\'s why Koffman and Wolfgang reinforce the message "think, then code" throughout their text. They embed the design and implementation of data structures into the practice of sound software engineering principles, introduced in early chapters and reinforced through the inclusion of case studies adapted to focus on the selection and/or design of Java classes.Over 20 case studies follow a five-step process (problem specification, analysis, design, implementation, and testing) that has been adapted to object-oriented programming to focus on the selection and/or design of Java classes. Students are encouraged to think critically about the five-step process and use it in an iterative fashion. Several problems have extensive discussions of testing and include methods that automate the testing process.Students gain an understanding of why different data structures are needed, the applications they are suited for, and the advantages and disadvantages of their possible implementations. Several problems have extensive discussions of testing and include methods that automate the testing process.Students who complete the text will be able to use the Java Collections framework and understand how it is implemented.Ultimately, Koffman and Wolfgang communicate the approach of "preparation breeds success" when it comes to Data Structures.

Table of Contents

Preface vii
Chapter 1 Introduction to Software Design 1(58)
1.1 The Software Life Cycle
2(9)
Software Life Cycle Models
3(2)
Software Life Cycle Activities
5(1)
Requirements Specification
6(1)
Analysis
7(1)
Design
8(3)
Exercises for Section 1.1
11(1)
1.2 Abstraction Helps Manage Complexity
11(2)
Procedural Abstraction
11(1)
Data Abstraction
12(1)
Information Hiding
12(1)
Exercises for Section 1.2
13(1)
1.3 Abstract Data Types, Interfaces, and Pre- and Postconditions
13(8)
Interfaces
14(2)
The implements Clause
16(1)
Declaring a Variable of an Interface Type
17(1)
An Interface for a Telephone Directory Class
17(1)
Javadoc Comments
17(1)
Contracts and Interfaces
18(1)
Preconditions and Postconditions
19(1)
Exercises for Section 1.3
20(1)
1.4 Requirements Analysis, Use Cases, and Sequence Diagrams
21(7)
Case Study: Designing a Telephone Directory Program
21(6)
Exercises for Section 1.4
27(1)
1.5 Design of an Array-Based Phone Directory
28(7)
Case Study: Designing a Telephone Directory Program (continued)
28(7)
Exercises for Section 1.5
35(1)
1.6 Implementing and Testing the Array-Based Phone Directory
35(7)
Case Study: Designing a Telephone Directory Program (continued)
35(7)
Exercises for Section 1.6
42(1)
1.7 Two Classes That Implement PDUserlnterface
42(12)
Case Study: Designing a Telephone Directory Program (continued)
43(11)
Exercises for Section 1.7
54(1)
Chapter Review, Exercises, and Programming Projects
54(5)
Chapter 2 Program Correctness and Efficiency 59(66)
2.1 Program Defects and "Bugs"
60(7)
Syntax Errors
61(1)
Run-time Errors or Exceptions
61(4)
Logic Errors
65(1)
Exercises for Section 2.1
66(1)
2.2 The Exception Class Hierarchy
67(4)
Exercises for Section 2.2
70(1)
2.3 Catching and Handling Exceptions
71(7)
Uncaught Exceptions
71(1)
The try-catch-finally Sequence
71(7)
Exercises for Section 2.3
78(1)
2.4 Throwing Exceptions
78(8)
The throws Clause
78(2)
The throw Statement
80(3)
Catching Exceptions in the Phone Directory Application
83(2)
Exercises for Section 2.4
85(1)
2.5 Testing Programs
86(14)
Structured Walkthroughs
87(1)
Levels and Types of Testing
87(2)
Preparations for Testing
89(1)
Testing Tips for Program Systems
90(1)
Developing the Test Data
91(1)
Testing Boundary Conditions
91(3)
Who Does the Testing?
94(1)
Stubs
94(1)
Drivers
95(1)
Testing a Class
95(2)
Using a Test Framework
97(1)
Regression Testing
98(1)
Integration Testing
98(1)
Exercises for Section 2.5
99(1)
2.6 Debugging a Program
100(5)
Using a Debugger
101(4)
Exercises for Section 2.6
105(1)
2.7 Reasoning about Programs: Assertions and Loop Invariants
105(4)
Assertions
106(1)
Loop Invariants
106(2)
Enrichment Topic: The Java assert statement
108(1)
Exercises for Section 2.7
109(1)
2.8 Efficiency of Algorithms
109(10)
Big-O Notation
112(4)
Comparing Performance
116(2)
Algorithms with Exponential and Factorial Growth Rates
118(1)
Exercises for Section 2.8
118(1)
Chapter Review, Exercises, and Programming Projects
119(6)
Chapter 3 Inheritance and Class Hierarchies 125(68)
3.1 Introduction to Inheritance and Class Hierarchies
126(7)
Is-a Versus Has-a Relationships
128(1)
A Superclass and a Subclass
128(1)
Use of this.
129(1)
Initializing Data Fields in a Subclass
130(1)
The No-Parameter Constructor
131(1)
Protected Visibility for Superclass Data Fields
131(1)
Exercises for Section 3.1
132(1)
3.2 Method Overriding, Method Overloading, and Polymorphism
133(5)
Method Overriding
133(2)
Method Overloading
135(1)
Polymorphism
136(1)
Exercises for Section 3.2
137(1)
3.3 Abstract Classes, Assignment, and Casting in a Hierarchy
138(5)
Referencing Actual Objects
141(1)
Abstract Classes and Interfaces
141(1)
Abstract Class Number and the Java Wrapper Classes
141(1)
Summary of Features of Actual Classes, Abstract Classes, and Interfaces
142(1)
Exercises for Section 3.3
143(1)
3.4 Class Object, Casting, and Cloning
143(13)
The Method toString
144(1)
Operations Determined by Type of Reference Variable
144(1)
Casting in a Class Hierarchy
145(4)
The Method Object.equals
149(1)
Cloning
150(4)
Cloning a Data Structure
154(1)
Exercises for Section 3.4
155(1)
3.5 Multiple Inheritance, Multiple Interfaces, and Delegation
156(4)
Using Multiple Interfaces to Emulate Multiple Inheritance
156(2)
Implementing Reuse Through Delegation
158(1)
Exercises for Section 3.5
159(1)
3.6 Packages and Visibility
160(3)
Packages
160(1)
The No-Package-Declared Environment
160(1)
Package Visibility
161(1)
Visibility Supports Encapsulation
161(2)
Exercises for Section 3.6
163(1)
3.7 A Shape Class Hierarchy
163(20)
Case Study: Drawing Geometric Figures
164(18)
Exercises for Section 3.7
182(1)
3.8 Object Factories
183(3)
Case Study: Compute Areas and Perimeters of Geometric Shapes
183(2)
Exercises for Section 3.8
185(1)
Chapter Review, Exercises, and Programming Projects
186(7)
Chapter 4 Lists and the Collection Interface 193
4.1 The List Interface and ArrayList Class
194(7)
The ArrayList Class
195(2)
Generic Collections
197(2)
Specification of the ArrayList Class
199(1)
Exercises for Section 4.1
200(1)
4.2 Applications of ArrayList
201(2)
The Phone Directory Application Revisited
201(1)
Exercises for Section 4.2
202(1)
4.3 Implementation of an ArrayList Class
203(6)
The Constructor for Class KWArrayList[E] 204
The add(E anEntry) Method
204(1)
The add(int index, E anEntry) Method
205(1)
The set and get Methods
206(1)
The remove Method
207(1)
The reallocate Method
207(1)
Implementing KWArrayList as a Collection of Objects
208(1)
Performance of the KWArrayList
208(1)
The Vector Class
208(1)
Exercises for Section 4.3
209(1)
4.4 Single-Linked Lists and Double-Linked Lists
209(13)
A List Node
211(2)
Connecting Nodes
213(1)
A Single-Linked List Class
213(1)
Inserting a Node in a List
214(1)
Removing a Node
214(1)
Traversing a Linked List
215(1)
Double-Linked Lists
216(3)
A Double-Linked List Class
219(1)
Circular Lists
219(1)
Exercises for Section 4.4
220(2)
4.5 The LinkedList Class and the Iterator, ListIterator, and Iterable Interfaces
222(8)
The LinkedList Class
222(1)
The Iterator
222(1)
The Iterator Interface
223(2)
The ListIterator Interface
225(3)
Comparison of Iterator and ListIterator
228(1)
Conversion Between a ListIterator and an Index
228(1)
The Enhanced for Statement
228(1)
The Iterable Interface
229(1)
Exercises for Section 4.5
229(1)
4.6 Implementation of a Double-Linked List Class
230(10)
Implementing the KWLinkedList Methods
231(1)
A Class that Implements the ListIterator Interface
232(7)
Inner Classes: Static and Non-Static
239(1)
Exercises for Section 4.6
239(1)
4.7 Application of the LinkedList Class
240(7)
Case Study: Maintaining an Ordered List
240(7)
Exercises for Section 4.7
247(1)
4.8 The Collection Hierarchy
247
Common Features of Collections
248(1)
The AbstractCollection, AbstractList, and AbstractSequentialList Classes
249(1)
Exercises for Section 4.8
250(1)
Chapter Review, Exercises, and Programming Projects
250
Chapter 5 Stacks 157(147)
5.1 Stack Abstract Data Type
258(3)
Specification of the Stack Abstract Data Type
258(2)
Exercises for Section 5.1
260(1)
5.2 Stack Applications
261(9)
Case Study: Finding Palindromes
261(3)
Case Study: Testing Expressions for Balanced Parentheses
264(5)
Exercises for Section 5.2
269(1)
5.3 Implementing a Stack
270(8)
Implementing a Stack as an Extension of Vector
270(1)
Implementing a Stack with a List Component
271(2)
Implementing a Stack Using an Array
273(2)
Implementing a Stack as a Linked Data Structure
275(2)
Comparison of Stack Implementations
277(1)
Exercises for Section 5.3
277(1)
5.4 Additional Stack Applications
278(18)
Case Study: Evaluating Postfix Expressions
279(5)
Case Study: Converting from Infix to Postfix
284(9)
Case Study: Part 2: Converting Expressions with Parentheses
293(3)
Tying Both Case Studies Together
296(1)
Exercises for Section 5.4
296(1)
Chapter Review, Exercises, and Programming Projects
296(8)
Chapter 6 Queues
6.1 Queue Abstract Data Type
304(4)
A Print Queue
304(1)
The Unsuitability of a "Print Stack"
305(1)
A Queue of Customers
305(1)
Using a Queue for Traversing a Multi-Branch Data Structure
305(1)
Specification for a Queue Interface
306(1)
Class LinkedList Implements the Queue Interface
307(1)
Exercises for Section 6.1
307(1)
6.2 Maintaining a Queue of Customers
308(6)
Case Study: Maintaining a Queue
308(5)
Exercises for Section 6.2
313(1)
6.3 Implementing the Queue Interface
314(11)
Using a Double-Linked List to Implement the Queue Interface
314(1)
Using a Single-Linked List to Implement the Queue Interface
315(2)
Using a Circular Array to Implement the Queue Interface
317(7)
Comparing the Three Implementations
324(1)
Exercises for Section 6.3
325(1)
6.4 Simulating Waiting Lines Using Queues
325(17)
Case Study: Simulate a Strategy for Serving Airline Passengers
326(15)
Exercises for Section 6.4
341(1)
Chapter Review, Exercises, and Programming Projects
342(6)
Chapter 7 Recursion
7.1 Recursive Thinking
348(8)
Steps to Design a Recursive Algorithm
350(2)
Proving That a Recursive Method Is Correct
352(1)
Tracing a Recursive Method
353(1)
The Run-Time Stack and Activation Frames
353(2)
Exercises for Section 7.1
355(1)
7.2 Recursive Definitions of Mathematical Formulas
356(7)
Recursion Versus Iteration
359(1)
Tail Recursion or Last-Line Recursion
359(1)
Efficiency of Recursion
360(3)
Exercises for Section 7.2
363(1)
7.3 Recursive Array Search
363(8)
Design of a Recursive Linear Search Algorithm
364(1)
Implementation of Linear Search
364(2)
Design of Binary Search Algorithm
366(1)
Efficiency of Binary Search
366(1)
The Comparable Interface
367(1)
Implementation of Binary Search
368(1)
Testing Binary Search
369(1)
Method Arrays.binarySearch
369(2)
Exercises for Section 7.3
371(1)
7.4 Recursive Data Structures
371(6)
Recursive Definition of a Linked List
371(1)
Class LinkedListRec
372(3)
Removing a List Node
375(1)
Exercises for Section 7.4
376(1)
7.5 Problem Solving with Recursion
377(10)
Case Study: Towers of Hanoi
377(5)
Case Study: Counting Cells in a Blob
382(5)
Exercises for Section 7.5
387(1)
7.6 Backtracking
387(6)
Case Study: Finding a Path Through a Maze
388(4)
Exercises for Section 7.6
392(1)
Chapter Review, Exercises, and Programming Projects
393(6)
Chapter 8 Trees
8.1 Tree Terminology and Applications
399(7)
Tree Terminology
399(1)
Binary Trees
400(1)
Some Types of Binary Trees
400(3)
Fullness and Completeness
403(1)
General Trees
404(1)
Exercises for Section 8.1
405(1)
8.2 Tree Traversals
406(2)
Visualizing Tree Traversals
406(1)
Traversals of Binary Search Trees and Expression Trees
407(1)
Exercises for Section 8.2
408(1)
8.3 Implementing a BinaryTree Class
408(9)
The Node[E] Class 408
The BinaryTree[E] Class 410
Exercises for Section 8.3
416(1)
8.4 Binary Search Trees
417(17)
Overview of a Binary Search Tree
417(1)
Performance
418(1)
Class TreeSet and Interface SearchTree
419(1)
The BinarySearchTree Class
419(2)
Insertion into a Binary Search Tree
421(4)
Removal from a Binary Search Tree
425(5)
Testing a Binary Search Tree
430(1)
Case Study: Writing an Index for a Term Paper
431(2)
Exercises for Section 8.4
433(1)
8.5 Heaps and Priority Queues
434(13)
Inserting an Item into a Heap
435(1)
Removing an Item from a Heap
435(1)
Implementing a Heap
436(3)
Priority Queues
439(1)
The PriorityQueue Class
440(1)
Using a Heap as the Basis of a Priority Queue
440(4)
The Other Methods
444(1)
Using a Comparator
444(1)
The compare Method
444(2)
Exercises for Section 8.5
446(1)
8.6 Huffman Trees
447(9)
Case Study: Building a Custom Huffman Tree
448(7)
Exercises for Section 8.6
455(1)
Chapter Review, Exercises, and Programming Projects
456(6)
Chapter 9 Sets and Maps
9.1 Sets and the Set Interface
462(5)
The Set Abstraction
463(1)
The Set Interface and Methods
464(2)
Comparison of Lists and Sets
466(1)
Exercises for Section 9.1
466(1)
9.2 Maps and the Map Interface
467(5)
The Map Hierarchy
468(1)
The Map Interface
469(2)
Exercises for Section 9.2
471(1)
9.3 Hash Tables
472(12)
Hash Codes and Index Calculation
472(1)
Methods for Generating Hash Codes
473(1)
Open Addressing
474(1)
Table Wraparound and Search Termination
475(1)
Traversing a Hash Table
476(1)
Deleting an Item Using Open Addressing
477(1)
Reducing Collisions by Expanding the Table Size
477(1)
Reducing Collisions Using Quadratic Probing
478(1)
Problems with Quadratic Probing
478(1)
Chaining
479(1)
Performance of Hash Tables
480(2)
Exercises for Section 9.3
482(2)
9.4 Implementing the Hash Table
484(12)
Interface KWHashMap
484(1)
Class Entry
484(2)
Class HashtableOpen
486(5)
Class HashtableChain
491(3)
Testing the Hash Table Implementations
494(1)
Exercises for Section 9.4
495(1)
9.5 Implementation Considerations for Maps and Sets
496(5)
Methods hashCode and equals
496(1)
Implementing HashSetOpen
497(1)
Writing HashSetOpen as an Adapter Class
497(1)
Implementing the Java Map and Set Interfaces
498(1)
Nested Interface Map.Entry
498(1)
Creating a Set View of a Map
499(1)
Method entrySet and Classes EntrySet and SetIterator
499(1)
Classes TreeMap and TreeSet
500(1)
Exercises for Section 9.5
501(1)
9.6 Additional Applications of Maps
501(8)
Case Study: Implementing the Phone Directory Using a Map
501(3)
Case Study: Completing the Huffman Coding Problem
504(4)
Exercises for Section 9.6
508(1)
Chapter Review, Exercises, and Programming Projects
509(5)
Chapter 10 Sorting
10.1 Using Java Sorting Methods
514(5)
Exercises for Section 10.1
518(1)
10.2 Selection Sort
519(3)
Analysis of Selection Sort
520(1)
Code for Selection Sort
520(1)
Exercises for Section 10.2
521(1)
10.3 Bubble Sort
522(3)
Analysis of Bubble Sort
523(1)
Code for Bubble Sort
524(1)
Exercises for Section 10.3
525(1)
10.4 Insertion Sort
525(4)
Analysis of Insertion Sort
527(1)
Code for Insertion Sort
528(1)
Exercises for Section 10.4
529(1)
10.5 Comparison of Quadratic Sorts
529(2)
Comparisons versus Exchanges
530(1)
Exercises for Section 10.5
530(1)
10.6 Shell Sort: A Better Insertion Sort
531(5)
Analysis of Shell Sort
532(1)
Code for Shell Sort
533(1)
Exercises for Section 10.6
534(2)
10.7 Merge Sort 535
Analysis of Merge
536(1)
Code for Merge
536(1)
Algorithm for Merge Sort
537(1)
Trace of Merge Sort Algorithm
538(1)
Analysis of Merge Sort
538(1)
Code for Merge Sort
539(1)
Exercises for Section 10.7
540(1)
10.8 Heapsort
540(5)
First Version of a Heapsort Algorithm
540(1)
Revising the Heapsort Algorithm
541(2)
Algorithm to Build a Heap
543(1)
Analysis of Revised Heapsort Algorithm
543(1)
Code for Heapsort
543(2)
Exercises for Section 10.8
545(1)
10.9 Quicksort
545(9)
Algorithm for Quicksort
546(1)
Analysis of Quicksort
546(1)
Code for Quicksort
547(2)
Algorithm for Partitioning 548
Code for partition
549(2)
A Revised Partition Algorithm
551(1)
Code for Revised partition Method
552(2)
Exercises for Section 10.9
554(1)
10.10 Testing the Sort Algorithms
554(2)
Exercises for Section 10.10
556(1)
10.11 The Dutch National Flag Problem (Optional Topic)
556(4)
Case Study: The Problem of the Dutch National Flag
556(4)
Exercises for Section 10.11
560(1)
Chapter Review, Exercises, and Programming Projects
560(6)
Chapter 11 Self-Balancing Search Trees
11.1 Tree Balance and Rotation
566(5)
Why Balance Is Important
566(1)
Rotation
567(1)
Algorithm for Rotation
567(2)
Implementing Rotation
569(1)
Exercises for Section 11.1
570(1)
11.2 AVL Trees
571(13)
Balancing a Left-Left Tree
571(1)
Balancing a Left-Right Tree
572(1)
Four Kinds of Critically Unbalanced Trees
573(2)
Implementing an AVL Tree
575(2)
Inserting into an AVL Tree
577(6)
Removal from an AVL Tree
583(1)
Performance of the AVL Tree
583(1)
Exercises for Section 11.2
583(1)
11.3 Red-Black Trees
584(13)
Insertion into a Red-Black Tree
585(10)
Removal from a Red-Black Tree
595(1)
Performance of a Red-Black Tree
596(1)
The TreeMap and TreeSet Classes
596(1)
Exercises for Section 11.3
596(1)
11.4 2-3 Trees
597(7)
Searching a 2-3 Tree
597(1)
Inserting an Item into a 2-3 Tree
598(4)
Analysis of 2-3 Trees and Comparison with Balanced Binary Trees
602(1)
Removal from a 2-3 Tree
602(2)
Exercises for Section 11.4
604(1)
11.5 2-3-4 and B-Trees
604(11)
2-3-4 Trees
604(3)
Implementation of TwoThreeFourTree Class
607(4)
Relating 2-3-4 Trees to Red-Black Trees
611(1)
B-Trees
612(2)
Exercises for Section 11.5
614(1)
Chapter Review, Exercises, and Programming Projects
615(8)
Chapter 12 Graphs 623(56)
12.1 Graph Terminology
624(5)
Visual Representation of Graphs
624(1)
Directed and Undirected Graphs
625(1)
Paths and Cycles
626(2)
Relationship Between Graphs and Trees
628(1)
Graph Applications
628(1)
Exercises for Section 12.1
629(1)
12.2 The Graph ADT and Edge Class
629(3)
Exercises for Section 12.2
631(1)
12.3 Implementing the Graph ADT
632(10)
Adjacency List
632(1)
Adjacency Matrix
632(2)
Overview of the Hierarchy
634(1)
Class AbstractGraph
634(3)
The ListGraph Class
637(3)
The MatrixGraph Class
640(1)
Comparing Implementations
640(1)
Exercises for Section 12.3
641(1)
12.4 Traversals of Graphs
642(13)
Breadth-First Search
642(5)
Depth-First Search
647(7)
Exercises for Section 12.4
654(1)
12.5 Applications of Graph Traversals
655(7)
Case Study: Shortest Path Through a Maze
655(4)
Case Study: Topological Sort of a Graph
659(3)
Exercises for Section 12.5
662(1)
12.6 Algorithms Using Weighted Graphs
662(9)
Finding the Shortest Path from a Vertex to All Other Vertices
662(4)
Minimum Spanning Trees
666(4)
Exercises for Section 12.6
670(1)
Chapter Review, Exercises, and Programming Projects
671(8)
Appendix A Introduction to Java 679(72)
A.1 The Java Environment and Classes
680(4)
The Java Virtual Machine
681(1)
The Java Compiler
681(1)
Classes and Objects
681(1)
The Java API
682(1)
The import Statement
682(1)
Method main
682(1)
Execution of a Java Program
683(1)
Exercises for Section Al
684(1)
A.2 Primitive Data Types and Reference Variables
684(6)
Primitive Data Types
684(1)
Primitive-Type Variables
685(1)
Primitive-Type Constants
686(1)
Operators
686(1)
Postfix and Prefix Increment
686(2)
Type Compatibility and Conversion
688(1)
Referencing Objects
689(1)
Creating Objects
689(1)
Exercises for Section A.2
690(1)
A.3 Java Control Statements
690(5)
Sequence and Compound Statements
690(1)
Selection and Repetition Control
691(2)
Nested if Statements
693(1)
The switch Statement
694(1)
Exercises for Section A.3
695(1)
A.4 Methods and Class math
695(4)
The Instance Methods println and print
695(1)
Call-by-Value Arguments
696(1)
The Class Math
697(1)
Escape Sequences
698(1)
Exercises for Section A.4
699(1)
A.5 The String, StringBuilder, StringBuffer, and StringTokenizer Classes
699(11)
The String Class
699(3)
Strings Are Immutable
702(1)
The Garbage Collector
702(1)
Comparing Objects
703(1)
The String.format Method
704(1)
The Formatter Class
705(1)
The StringBuilder and StringBuffer Classes
706(1)
The StringTokenizer Class
707(2)
Exercises for Section A.5
709(1)
A.6 Wrapper Classes for Primitive Types
710(2)
Exercises for Section A.6
711(1)
A.7 Defining Your Own Classes
712(14)
Private Data Fields, Public Methods
716(1)
Constructors
716(1)
The No-Parameter Constructor
717(1)
Modifier and Accessor Methods
717(1)
Use of this. in a Method
718(1)
The Method toString
718(1)
The Method equals
718(2)
Declaring Local Variables in Class Person
720(1)
An Application That Uses Class Person
720(1)
Objects as Arguments
721(2)
Classes as Components of Other Classes
723(1)
Java Documentation Style for Classes and Methods
723(2)
Exercises for Section A.7
725(1)
A.8 Arrays
726(10)
Data Field length
728(1)
Method System.arraycopy
729(1)
Array Data Fields
730(2)
Array Results and Arguments
732(1)
Arrays of Arrays
732(2)
Exercises for Section A.8
734(2)
A.9 Input/Output Using Class JOptionPane
736(3)
Converting Numeric Strings to Numbers
737(1)
GUI Menus Using Method showOptionDialog
738(1)
Exercises for Section A.9
738(1)
A.10 Input/Output Using Streams
739(7)
Input Streams
739(1)
Console Input
739(1)
Output Streams
740(1)
Passing Arguments to Method main
740(1)
Closing Streams
740(1)
Exceptions
741(1)
A Complete File-Processing Application
741(2)
The Scanner
743(1)
Tokenized Input
744(1)
Exercises for Section A.10
745(1)
Chapter Review, Exercises, and Programming Projects
746(5)
Appendix B Overview of UML 751(10)
B.1 The Class Diagram
752(6)
Representing Classes and Interfaces
752(3)
Generalization
755(1)
Inner or Nested Classes
756(1)
Association
756(1)
Aggregation and Composition
757(1)
Generic Classes
758(1)
B.2 Sequence Diagrams
758(3)
Time Axis
758(1)
Objects
759(1)
Life Lines
760(1)
Activation Bars
760(1)
Messages
760(1)
Use of Notes
760(1)
Appendix C Event-Oriented Programming 761(68)
C.1 Elements of an Event-Oriented Application
762(8)
Components and Events
763(1)
Event Listeners
764(1)
The ActionListener Interface
764(1)
Registering an Event Listener
765(1)
Creating a User Interface
766(3)
Exercises for Section C.1
769(1)
C.2 Overview of the AWT and Swing Hierarchy
770(8)
Example and Overview: TwoCircles
771(4)
JFrame
775(1)
JPanel
776(1)
Graphics
777(1)
Graphics Coordinates
778(1)
Exercises for Section C.2
778(1)
C.3 Layout Managers
778(7)
Border Layout
779(2)
Flow Layout
781(1)
Box Layout
782(1)
Grid Layout
783(1)
Combining Layouts
784(1)
Exercises for Section C.3
785(1)
C.4 Components for Data Entry
785(8)
Check Box
786(1)
Radio Button
787(2)
Combo Box
789(1)
Text Field
790(2)
Label
792(1)
Text Area
792(1)
Exercises for Section C.4
792(1)
C.5 Using Data Entry Components in a GUI
793(8)
Case Study: Liquid Volume Converter
793(5)
Limiting the Number of Significant Digits
798(1)
Formatting Currency for Different Locales
799(1)
Exercises for Section C.5
800(1)
C.6 Menus and Toolbars
801(12)
The Classes JMenuItem, JMenu, and JmenuBar
801(2)
Icons
803(1)
Toolbars
803(2)
Case Study: A Drawing Application
805(8)
Exercises for Section C.6
813(1)
C.7 Processing Mouse Events
813(10)
MouseAdapter and MouseMotionAdapter
814(1)
Case Study: A Drawing Application (continued)
815(8)
Exercises for Section C.7
823(1)
Chapter Review, Exercises, and Programming Projects
823(6)
Glossary 829(10)
Index 839


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