CART

(0) items

An Object-Oriented Approach to Programming Logic and Design,9780619215637
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.

An Object-Oriented Approach to Programming Logic and Design

by
Edition:
1st
ISBN13:

9780619215637

ISBN10:
0619215631
Format:
Paperback
Pub. Date:
1/12/2005
Publisher(s):
Cengage Learning
List Price: $167.33

Buy New Textbook

Currently Available, Usually Ships in 24-48 Hours
$163.15

Rent Textbook

We're Sorry
Sold Out

Used Textbook

We're Sorry
Sold Out

eTextbook

We're Sorry
Not Available

More New and Used
from Private Sellers
Starting at $0.01

Questions About This Book?

What version or edition is this?
This is the 1st edition with a publication date of 1/12/2005.
What is included with this book?
  • The New copy of this book will include any supplemental materials advertised. Please check the title of the book to determine if it should include any CDs, lab manuals, study guides, etc.

Related Products


  • An Object-oriented Approach to Programming Logic and Design
    An Object-oriented Approach to Programming Logic and Design
  • An Object-Oriented Approach to Programming Logic and Design
    An Object-Oriented Approach to Programming Logic and Design
  • An Object-oriented Approach to Programming Logic and Design
    An Object-oriented Approach to Programming Logic and Design
  • An Object-Oriented Approach to Programming Logic and Design, 3rd Edition
    An Object-Oriented Approach to Programming Logic and Design, 3rd Edition




Summary

Joyce Farrell has taken the proven pedagogy from her structural, traditional text (Programming Logic and Design, now in its third edition) and applied an object-oriented approach for introductory programming students. This text introduces Classes, Objects, Behaviors, and Attributes very early on. It also includes chapters on other object-oriented topics such as inheritance and exception handling.

Table of Contents

Preface xv
An Overview of Computers and Logic
1(30)
Understanding Computer Components and Operations
2(3)
Understanding the Evolution of Programming Techniques
5(2)
Understanding the Programming Process
7(4)
Identifying Objects, Creating Classes, and Establishing Communication
8(1)
Coding the Program
8(1)
Translating the Program into Machine Language
8(1)
Testing the Program
9(2)
Putting the Program into Production
11(1)
Using Flowcharts and Pseudocode Statements
11(1)
Creating an Application Class with a main() Method
12(3)
Using and Naming Variables
15(1)
Assigning Values to Variables
16(2)
Understanding Data Types
18(4)
Chapter Summary
22(1)
Key Terms
22(3)
Review Questions
25(3)
Exercises
28(1)
Case Problem
29(2)
Object-Oriented Programming Concepts
31(24)
An Overview of Object-Oriented Programming
32(2)
Defining Classes and Creating Class Diagrams
34(2)
Understanding Public and Private Access
36(2)
Instantiating and Using Objects
38(2)
Understanding Inheritance
40(4)
Using Polymorphism
43(1)
Understanding Protected Access
44(1)
One Example of Using Predefined Classes: Creating GUI Objects
45(1)
Understanding the Advantages of Object-Oriented Programming
46(1)
Chapter Summary
47(1)
Key Terms
48(1)
Review Questions
49(3)
Exercises
52(1)
Case Problem
53(2)
Using Methods and Parameters
55(26)
Creating Methods With and Without Arguments
56(11)
Creating Methods with No Arguments
57(2)
Creating Methods that Require a Single Argument
59(3)
Creating Methods that Require Multiple Arguments
62(1)
Creating Methods that Return Values
63(1)
Creating Instance Methods in a Class
64(3)
Exploring the Rationale Behind Data Hiding
67(1)
Organizing Classes
68(1)
Understanding the Role of the this Reference
69(2)
An Introduction to Using Constructors
71(2)
Chapter Summary
73(1)
Key Terms
74(1)
Review Questions
75(2)
Exercises
77(2)
Case Problem
79(2)
Understanding Structure
81(42)
The Role of Structure in Object-Oriented Methods
82(1)
Drawing Flowcharts
82(2)
Understanding Unstructured Spaghetti Code
84(2)
Understanding the Three Basic Structures of Sequence, Selection, and Loop
86(3)
The Sequence Structure
86(1)
The Selection Structure
86(2)
The Loop Structure
88(1)
Building Structured Methods
89(4)
Using a Priming Read
93(6)
Understanding the Reasons for Structure
99(3)
Recognizing Structure
102(6)
Describing Two Special Structures---Case and Do Until
108(6)
The Case Structure
109(1)
The Do Until Loop
110(4)
Chapter Summary
114(1)
Key Terms
114(1)
Review Questions
115(3)
Exercises
118(4)
Case Problem
122(1)
Making Decisions
123(58)
Evaluating Boolean Expressions to Make Comparisons
124(2)
Using the Relational Comparison Operators
126(4)
Making Decisions with Objects
130(3)
Making Decisions About Primitive Data Types
130(1)
Making Decisions About Objects
131(2)
Understanding AND Logic
133(7)
Nesting AND Decisions for Efficiency
135(2)
Combining Decisions in an AND Selection
137(1)
Avoiding Common Errors in an AND Selection
138(2)
Understanding OR Logic
140(7)
Writing OR Decisions for Efficiency
141(2)
Combining Decisions in an OR Selection
143(1)
Avoiding Common Errors in an OR Selection
144(3)
Using Selections within Ranges
147(7)
Understanding Common Errors Using Range Checks
154(3)
Understanding Precedence When Combining AND and OR Selections
157(2)
Understanding the Case Structure
159(2)
Using Decision Tables
161(6)
Chapter Summary
167(1)
Key Terms
168(1)
Review Questions
169(4)
Exercises
173(5)
Case Project
178(3)
Looping
181(36)
Understanding the Advantages of Looping
182(1)
Controlling Loops with Variables, Counters, and Sentinel Values
182(10)
Using a While Loop with a Loop Control Variable
183(5)
Using a Counter to Control Looping
188(1)
Using Constant and Variable Sentinel Values
189(3)
Looping by Decrementing
192(1)
Avoiding Common Loop Mistakes
192(3)
Neglecting to Initialize the Loop Control Variable
193(1)
Neglecting to Alter the Loop Control Variable
193(1)
Using the Wrong Comparison with the Loop Control Variable
194(1)
Including Statements Inside the Loop that Belong Outside the Loop
194(1)
Using A for Loop
195(2)
Using A Do Until Loop
197(2)
Recognizing the Characteristics Shared by All Loops
199(1)
Nesting Loops
200(4)
Using a Loop to Accumulate Totals
204(3)
Chapter Summary
207(1)
Key Terms
207(1)
Review Questions
208(4)
Exercises
212(3)
Case Project
215(2)
Arrays
217(36)
Understanding Arrays and How They Occupy Computer Memory
218(2)
How Arrays Occupy Computer Memory
218(2)
Manipulating an Array to Replace Nested Decisions
220(6)
Array Declaration and Initialization
226(2)
Initialized and Uninitialized Arrays
228(2)
Loading an Array from a File
230(2)
Searching an Array for an Exact Match
232(5)
Using Parallel Arrays
234(2)
Improving Search Efficiency Using an Early Exit
236(1)
Using a Constant to Store an Array Size
237(1)
Searching an Array for a Range Match
238(4)
Chapter Summary
242(1)
Key Terms
242(1)
Review Questions
243(3)
Exercises
246(4)
Case Project
250(3)
Advanced Array Concepts
253(28)
Remaining within Array Bounds
254(1)
Using a for Loop to Process Arrays
255(2)
Declaring an Array of Objects
257(1)
Passing Arrays to Methods
258(4)
Sorting Array Elements
262(3)
Sorting Arrays of Objects
265(2)
Using Two-Dimensional and Multidimensional Arrays
267(2)
Using a Built-In Arrays Class
269(3)
Chapter Summary
272(1)
Key Terms
272(1)
Review Questions
273(4)
Exercises
277(3)
Case Project
280(1)
Event-Driven Programming with Graphical User Interfaces
281(22)
Understanding Event-Driven Programming
282(2)
User-Initiated Actions and GUI Components
284(2)
Designing Graphical User Interfaces
286(2)
The Interface Should Be Natural and Predictable
286(1)
The Interface Should Be Attractive, Easy to Read, and Nondistracting
287(1)
To Some Extent, It's Helpful If the User Can Customize Your Applications
287(1)
The Program Should Be Forgiving
288(1)
The GUI is Only a Means to an End
288(1)
Modifying the Attributes of GUI Components
288(1)
The Steps to Developing an Event-Driven Application
289(3)
Creating Storyboards
289(1)
Defining the Objects in an Object Dictionary
290(1)
Defining the Connections Between the User Screens
291(1)
Planning the Logic
291(1)
Understanding Multithreading
292(2)
Creating Animation
294(3)
Chapter Summary
297(1)
Key Terms
297(1)
Review Questions
298(3)
Exercises
301(1)
Case Project
302(1)
Modeling With UML
303(26)
Understanding the Need for System Modeling
304(1)
What Is UML?
304(2)
Using Use Case Diagrams
306(5)
Using Class and Object Diagrams
311(4)
Using Sequence and Collaboration Diagrams
315(2)
Using Statechart Diagrams
317(1)
Using Activity Diagrams
318(1)
Using Component and Deployment Diagrams
319(2)
Deciding Which UML Diagrams to Use
321(1)
Chapter Summary
322(1)
Key Terms
322(1)
Review Questions
323(3)
Exercises
326(1)
Case Project
327(2)
Object Concepts: Polymorphism and Inheritance
329(34)
Understanding Blocks and Scope
330(6)
Overloading a Method
336(1)
Learning About Ambiguity
337(1)
Overloading Constructors
338(2)
Learning About the this Reference
340(2)
Learning About the Concept of Inheritance
342(4)
Extending Classes
346(1)
Overriding Superclass Methods
347(2)
Understanding How Constructors Are Called During Inheritance
349(1)
Learning About Information Hiding
349(2)
Using Inheritance to Achieve Good Software Design
351(1)
Chapter Summary
352(1)
Key Terms
353(1)
Review Questions
354(3)
Exercises
357(3)
Case Project
360(3)
Exception Handling
363(1)
Learning About Exceptions
364(1)
Understanding the Limitations of Traditional Error Handling
365(1)
Trying Code and Catching Exceptions
366(2)
Throwing and Catching Multiple Exceptions
368(3)
Using the finally Block
371(2)
Understanding the Advantages of Exception Handling
373(2)
Specifying the Exceptions a Method Can Throw
375(2)
Tracing Exceptions Through the Call Stack
377(1)
Creating Your Own Exceptions
378(3)
Chapter Summary
381(1)
Key Terms
382(1)
Review Questions
382(3)
Exercises
385(2)
Case Project
387
Appendix A Solving Difficult Structuring Problems 1(1)
Appendix B Understanding Numbering Systems and Computer Codes 1(1)
Appendix C Using a Large Decision Table 1(1)
Glossary 1(1)
Index 1


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