An Object-Oriented Approach to Programming Logic and Design

by Farrell, Joyce

• ISBN13: 9780619215637
• ISBN10: 0619215631
• Edition: 1st
• Format: Paperback
• Copyright: 2005-01-12
• Publisher: Course Technology

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