This specific ISBN edition is currently not available.View all copies of this ISBN edition:
Click for author interviews and demos of four SimpleGUI examples. Object-Oriented Programming This book presents a careful balance between traditional problem-solving techniques and object-oriented design. Embracing the object-oriented paradigm, the authors introduce objects early (Chapter 2) and use them throughout, introducing features as needed in a gentle manner. Chapters 4 - 7 focus on the traditional data and control structures, using objects as needed. Chapter 8 provides a more in-depth study of object-oriented design, providing detailed coverage of visibility, polymorphism, and inheritance. Applications and Applets Focusing on applications early, the book supports user interaction by providing a package called simpleIO. Applets are first introduced in Chapter 4 where the authors use them in an optional section on graphics to introduce the AWT and its features for drawing simple graphical patterns. They are studied extensively in Chapters 9 and 10 where the intricacies of the AWT, programming for the web, and GUI programming are covered.Graphical User Interfaces (GUIs) Starting in Chapter 2, the authors integrate a GUI library that allows students to better understand concepts through visualization and have some fun. GUI concepts are always presented in the context of good problem solving and program development. Optional sections on graphics appear starting in Chapter 4, again to spur student interest and keep them motivated. Proven Software Development Process The book conveys the relationship between good problem-solving skills and effective software development by consistently applying a proven software development method that has been adapted to the object-oriented paradigm. Helpful Learning Features The authors employ several features to enhance the usefulness of this book as a teaching tool. These include syntax displays, program style displays, end-of-section exercises, examples, case studies, error discussions, and chapter reviews. Also, interviews with famous computer scientists provide glimpses into various careers in computer science. 0201357437B04062001
"synopsis" may belong to another edition of this title.
Elliot Koffman is a professor of computer and information science at Temple University. He is one of the country's foremost CS educators, a former chairman of the ACM Task Force for introductory programming methods courses, and author of a number of successful language texts in Modula-2, FORTRAN, in addition to his four editions of Pascal and Turbo Pascal.Dr. Ursula Wolz is an assistant professor and former chair of the computer science department at the College of New Jersey. She has been teaching programming for 20 years and has been involved in research in object-oriented design, artificial intelligence, and intelligent user interfaces during this period. She has published widely on issues concerning computer science education and has received National Science Foundation funding for CS curriculum development.0201357437AB04062001Excerpt. © Reprinted by permission. All rights reserved.:
This textbook is intended for a first course in problem solving and program design with Java (CS 1). It assumes no prior knowledge of computers or programming, and for most of its material, high school algebra is sufficient mathematics background. A limited knowledge of discrete mathematics is desirable for a few sections.
Problem Solving and Program Design
The primary emphasis in this text is on problem solving with Java. We accomplish this by selecting features of the language that lend themselves to good program design. We also emphasize abstraction and follow a standard five-step approach to program design (problem specification, analysis, design, implementation, and testing). We have modified this time-tested approach for software development to the object-oriented paradigm. We follow it faithfully in the solution of more than 20 case studies throughout the book. Ten of the case studies are new to this edition.
Classes and Objects Early
Students use predefined classes like String and Math to write small applications in Chapter 2. They begin to write their own worker classes to model real-world objects in Chapter 3. Examples are a FoodItem class, a CoinChanger class, a Circle class, and a Washer class. Methods are introduced in Chapter 2 and thoroughly covered in Chapter 3.
Object-Oriented Programming (OOP)
We continue to use worker classes in applications and discuss OOP concepts in an informal manner. We provide a detailed discussion of OOP in Chapter 6. We introduce class hierarchies, inheritance, interfaces, and abstract classes by studying several case studies that use these features.
Standard Input/Output Stressed
We use standard Java for input and output. Starting in Chapter 1, we use class JOptionPane (part of Swing) for windows-based input and output and we use the console window for more extensive output. In Chapter 3, we provide an optional package with static methods for input (based on JOptionPane) that simplifies data entry with dialog windows. The input methods check for number format errors and can check for range violations. Most programs in the book use standard Java I/O methods, but students can use the optional package if they wish.
This is a departure from the first edition, which utilized a nonstandard graphical user interface (GUI) package. Our experience is that many of the benefits of this package can be derived through class JOoptionPane. Many Java programming instructors preferred to teach standard methods rather than rely on a nonstandard package. We hope that we have met the needs of most users by relying on standard input/output and by also providing an optional nonstandard package that is simpler to use.
Applets and Applications
We focus on applications in Chapters 2 and 3, where we attempt to teach the basics of simple programs that calculate results. We use applications rather than applets because we don't want students to have to deal with the details of providing a GUI. We introduce applets, HyperText Markup Language (HTML), and graphics programming using the AWT Graphics class to draw simple graphical patterns in Chapter 3. When we cover GUIs in Chapter 7, we use Swing components. (see below).
Control Structures and Indexed Data Structures
In this edition, we cover selection and loop control structures together in Chapter 4. However, the control structures are not intermixed. We complete the selection control structures before we begin loop control structures, so instructors can separate these structures if they wish to.
We study arrays in Chapter 5, along with other Java indexed data collections, the Vector class and ArrayList class. We also discuss wrapper classes for the primitive types in this chapter.
We revisit applets and HTML in Chapter 7 when we describe how to build GUIs using Swing components. We also show how to use class JFrame to write applications that have GUIs. We show several examples of GUIs in both applications and applets.
Exceptions and Streams
Chapter 8 is a new chapter on exceptions and streams. Knowing how to catch and throw exceptions is critical to stream processing, so we begin the chapter with a discussion of exceptions. The chapter covers streams of characters, binary streams, and streams of objects.
Coverage of Advanced Topics
Chapters 9 and 10 concern themselves with more traditional aspects of programming often found in CS2: recursion and processing linked data structures. We develop classes for linked lists, stacks, queues, and binary search trees. We define the node structure in inner classes. We also show how to use the LinkedList collection class and the ListIterator class. Many CS1 courses would not include this advanced material.
Flexibility of Coverage
There is sufficient material in the textbook for one and a half semesters or for two quarters. We consider Chapters 1 through 7 the core of the book, and they should be covered by all students. The first four chapters (through control structures) must be covered in sequence:
1. Introduction to Computers, Problem Solving, and Programming
2. Using Primitive Data Types and Using Classes
3. Object-Oriented Design and Writing Worker Classes
4. Control Structures: Decisions and Loops
The next three chapters deal with arrays, OOP, and GUI design, and they can be covered in a variety of ways:
5. Arrays and Vectors
6. Class Hierarchies, Inheritance, and Interfaces
7. Graphical User Interfaces (GUIs)
Faculty who want to cover GUIs earlier can cover Chapter 7 first, omitting the few examples that involve arrays. Similarly, faculty who want to cover OOP details earlier can introduce the fundamentals of using arrays (Sections 5.1-5.3) and then cover Chapter 6 in detail. Then continue with the rest of Chapter 5 or Chapter 7.
Chapter 9, Recursion, could also be introduced earlier. Sections 9.1-9.3 could be covered after Chapter 4 and the rest of the chapter could be covered after Chapter 5.
We employ several pedagogical features to enhance the usefulness of the book as a teaching tool. Discussion of some of these features follows.
End-of-Section Exercises: Most sections end with a number of self-check exercises, including exercises that require analysis of program fragments as well as short programming exercises. Answers to odd-numbered self-check exercises appear at the back of the book; answers to other exercises are provided in the Instructor's Manual.
End-of-Chapter Exercises: Each chapter ends with a set of quick-check exercises with answers. There are also chapter review exercises with solutions provided in the Instructor's Manual.
End-of-Chapter Projects: There are several projects at the end of each chapter that are suitable for programming assignments. Answers to selected projects appear in the Instructor's Manual.
Examples and Case Studies: The text contains a large number and variety of programming examples. Whenever possible, examples contain complete class or method definitions rather than incomplete fragments. Each chapter contains one or more case studies that are solved following the software development method.
Syntax Displays: The syntax displays describe the syntax and semantics of each new Java feature complete with examples.
Program Style Displays: The program style displays discuss issues of good programming style.
Error Discussions and Chapter Review: Each chapter ends with a section that discusses common programming errors. Chapter reviews include a table of new Java constructs.
Appendixes and Supplements
Appendixes: The text concludes with several appendixes covering the Java language, HTML, unicode, Borland JBuilder, resources for finding out more about Java, and a summary of Java class libraries.
Packages and Classes: Further information about this textbook can be found at www.awcom/cssupport. You will be able to download package psJava and source code for all the classes provided in the textbook.
Instructor's Manual: Access to an online instructor's manual is available through your Addison-Wesley sales representative. The Instructor's Manual contains answers to selected exercises and projects and is available to qualified instructor's only
There were many individuals without whose support this book could not have been written. These include the principal reviewers of this edition and the first edition:
Julia E. Benson, DeKalb College
Richard J. Boning, California State University San Bernadino
Tom Corona, SUNY at Stony Brook
Robert H. Dependahl, Jr., Santa Barbara City College
Bill Grosky, Wayne State University
Stanley H. Lipson, Kean University of New Jersey
David Mathias, Ohio State University
Bina Ramamurthy, SUNY at Buffalo
Stuart Reges, University of Arizona
James Svoboda, Clarkson University
John S. Ze1ek, University of Guelph
Several students at The College of New Jersey (TCNJ) and Temple University helped with the development of the textbook. They include Brice Behringer, Greg Bronevetsky George Drayer, William Fenstermaker, Mark Nikolsky, Brian Robinson, and Michael Sipper...
"About this title" may belong to another edition of this title.
Book Description Addison-Wesley, 1998. Condition: New. book. Seller Inventory # M0201357437
Book Description Addison-Wesley, 1998. Paperback. Condition: New. Seller Inventory # DADAX0201357437