The Object of Data Abstraction and Structures is for readers who are looking for a second computer science course that focuses on a modern object-oriented approach in Java. It covers the traditional data structures topics of a CS2 course, with special attention to sound software engineering practice, and uses an object-oriented approach.
The presentation is divided into two parts to provide instructors maximum flexibility to tailor the material to their particular needs. The main body of the textbook consists of Chapters 1 - 9 with general topics that are common to most CS2 courses, but with a distinctly O-O flavor. The Core Concepts: Review and Reference sections of the book is a collection of foundational material that is assumed within the main body. These topics include an introduction to object-oriented programming, software specifications, inheritance, exceptions and recursion. Most CS2 courses expect some, but not all, of this core material as prerequisite, but there are considerable differences from course-to-course. This core material may be covered whenever the instructor chooses, or omitted altogether.
Sprache
Verlagsort
Verlagsgruppe
Zielgruppe
Für höhere Schule und Studium
Maße
Höhe: 230 mm
Breite: 187 mm
Dicke: 26 mm
Gewicht
ISBN-13
978-0-201-71359-6 (9780201713596)
Copyright in bibliographic data and cover images is held by Nielsen Book Services Limited or by the publishers or by their respective licensors: all rights reserved.
Schweitzer Klassifikation
David D. Riley is chairman of the Department of Computer Science at University of Wisconsin-LaCrosse, where he teaches programming for beginners and for experienced programmers. His areas of specialty include object-oriented software development, software engineering, and computer architecture. He holds a Ph.D. in Computer Science from the University of Iowa.
Professor Riley is the author of four other programming books, including Data Abstraction and Structures using C++ with Mark Headington.
SECTION 1.
Abstraction.
Abstract Data Types.
Specification and Abstraction.
ADT Design Principles.
Template Design Pattern.
Interfaces.
The Object Class.
Containers.
Intro to Containers.
Generic Containers.
Wrapper Classes.
Bounded Containers.
Sequences.
String.
Mutability.
Iterators.
Collections and Enumerations.
Performance Considerations.
Algorithms and Counting.
Big-oh Notation.
Run-time Performance of Control Various Structures.
Arrays and Tables.
Review of One-Dimensional Arrays.
An Array Implementation of BoundedSet.
Representations.
Implementing Iterator.
Implementing Collection (optional).
The Vector Class.
Multidimensional Arrays.
Array of Arrays.
Tables.
Bit Vectors.
Finite State Machines.
Lists and List Implementations.
Data Lifetime.
The Singleton Design Pattern.
Dynamic Data Allocation and Deallocation.
Objects Referencing Like Objects.
One-way Lists and Single Linking.
Implementing a Simple Singly- linked List.
List Implementation Improvements - Sentinel Nodes & Pre-pointers.
Multiple Iterators Per List.
Iterator Integrity.
Circular Lists.
Two-way Lists and Double Linking.
java.util.list and java.util.LinkedList (optional).
Implementing a List with an Array.
Other Linear Containers (Stacks and Queues).
Stack as a Container ADT.
Sample Stack Applications.
List Implementations of Stack.
An Array Implementation of Stack.
java.util.Stack.
Queue as a Container ADT.
A List Implementation of Queue.
Ring Buffer Implementation of Queue.
Priority Queue.
Maps.
Map ADT.
Implementing Map in a List.
Implementing Map as an Array Table.
Hash Tables.
Implementing Map as a Hash Table.
java.util.Map and java.util.HashMap.
Trees.
Introduction to Trees.
Tree Applications.
Binary Trees.
A Binary Tree and Iterator.
Tree Traversal Algorithms.
Binary Search Trees.
Linked Implementations of Binary Trees.
An Array Implementation of Binary Tree.
General Trees.
SECTION 2. CORE CONCEPTS: REVIEW AND REFERENCE.
Object-oriented Programming.
Objects and Classes.
Java Applications.
Class Diagrams.
Implementing a Design.
Program Execution - Object Diagrams.
Testing and Debugging.
Java Applets.
Software Specifications.
Why Specify?
Class Diagrams.
A Language for Expressing Specifications.
Common Assertion Patterns.
Designing and Programming by Contract.
Preconditions and Postconditions.
Class Specifications.
Inheritance.
Extension and Specialization.
is_a Relationships.
Inheritance in Java.
Scope and Inheritance.
Type Conformance.
Dynamic Dispatch and Polymorphism.
Abstract Classes.
Exceptions.
Robustness and Exceptions.
Exception Handling.
Exception Recovery.
Standard Exceptions.
Specifying with Exceptions.
Files and Streams.
Files.
The Java File Class.
Input and Output.
DataInputStream and DataOutputStream.
Text Files.
Terminal-style I/O (optional).
Persistent Objects.
Recursion.
Recursive Definition.
BNF.
Recursion in Specification Functions.
From Recursive Definition to Method.
Recursive Methods.
Recursive Execution.
Recursion and Repetition.
More Complicated Forms of Recursion.
