This title fully embraces the object-oriented paradigm by taking an objects-centric approach to presenting problem solving and programming. Readers begin with four complete chapters focusing on objects, classes and methods. The presentation of primitive data occurs in Chapter 5, ensuring the necessary prior exposure to object declaration, object instantiation, assignment, method calling, parameter passage, class diagrams and object diagrams. The topics of aggregation and inheritance occur earlier than many other CS1 books. In order to accommodate this placement of topics, control structures are covered later than other books. Through many semesters of class-testing this objects-centric approach, students have developed high degree of student competence with both object-oriented features and the "classic" language features such as numeric expressions and control structures. This book focuses on the skills and discipline of software engineering that are needed for good programming.
Since specifications are critical for conveying code behavior in the object-oriented model, discussions of method preconditions and postconditions, and class invariants are used consistently to document examples and to define example classes. The unified modelling language is used extensively as the specification language. The book also uses the notion of patterns to identify numerous expressions, instructions, algorithms and designs that serve to pattern program segments. This BlueJ version integrates the use of BlueJ throughout the presentation. Explanation of BlueJ facilities for programming, testing and debugging are included along with these topical discussions. An appendix that demonstrates key BlueJ features is also included.
Table of Contents:
1. Objects and Classes.
Objects Everywhere.
Objects in Software.
Anatomy of a Software Class.
The Difference Between Objects and Classes.
Edit, Compile and Run.
Programming with BlueJ.
Introduction to Software Engineering.
A Sample of Object-oriented Software Development.
2. Introduction to Java Objects.
Syntax Diagrams.
The Method Call.
Instruction Sequences.
Constructing and Assigning Objects.
Swapping.
Putting it Together in a Java Class.
Programming by Contract.
Comments.
BlueJ Debugging.
3. Introduction to Design & Implementation.
Top-down Design — Refining Algorithms.
Selecting Identifiers.
A Second Design Example.
A GUI Software Library.
Calling Methods with Parameters.
Import Declarations.
Prototyping.
Debugging with BlueJ and System.out.println.
Summary.
4. Methods.
The Need for a Subprogram.
Private Parameterless Methods.
Using Parameters.
Local Variables.
Non-void Methods.
Debugging Methods.
this.
Introduction to Event Handling.
Postcondition Notation.
A Design Example Using AView.
5. Numeric Processing.
Primitive Types.
Primitive Integer Data Types.
Differences Between Primitives and References.
Real Numbers (float and double types).
System.out.println Revisited.
Mixed Type Numeric Expressions.
Primitive Methods (including Math).
Constants (final).
6. Supplier Classes.
Clients and Suppliers in Software.
Another Client.
Suppliers.
Manipulating Suppliers with BlueJ.
Scope and Lifetime.
Class Interface Design Principles.
Separating Read and Write Access.
Method Overloading.
char Data Type.
Strings.
ALabel (optional).
7. Logic and Selection.
The if Instruction.
Relational Expressions.
Boolean Expressions.
Conditional Evaluation.
Predicates.
Nestingif Instructions.
Multi-way Selection.
The switch Instruction.
Software Testing.
Logic and Programming (optional).
Assertions (optional).
8. Inheritance.
Extends.
Class Relations: contains_a and is_a.
Specialization and Extension.
protected Scope.
Inheriting for Event Handling.
Animating by Inheriting EventTimer (optional).
Design Example with Scrollbars and Text Fields (optional).
Summary.
9. Inheritance Hierarchies and Polymorphism.
Inheritance Hierarchies.
Type Conformance.
Subtype Polymorphism.
Abstract Classes.
The Object Class.
Equality by Content and by Identity.
10. Repetition.
The while Loop.
Counting Loops.
Sentinel Loops.
Loop Design Cautions.
Nested Loops.
Thedo loop.
Loop Invariants.
Looping and Event Handling.
Testing and Loops.
11. Containers.
Containers of Objects.
Generic Containers.
Type Safety, Casting, and instanceOf.
Wrapper Classes.
Lists.
List Traversal.
Linear Searching.
Sorting by Insertion.
12. Introduction to Arrays.
One-dimensional Arrays.
Keeping Indices in Bounds.
Sequential Processing with for Loops.
Treating Arrays in Aggregate.
Tables.
Arrays of Objects.
Arrays and Objects.
Sorting — The Selection Sort.
Two-dimensional Arrays.
13. File Input and Output.
Files.
The Java File Class.
I/O Exceptions.
Input and Output.
DataInputStream and DataOutputStream.
Text Files.
Terminal-style I/O.
Persistent Objects (optional).
JFileChooser (optional).
14. Recursion.
Recursive Definition.
From Recursive Definition to Method.
Recursive Methods.
Recursive Execution.
Recursion and Repetition.
More Complicated Forms of Recursion.
15. Library Issues: Packages, Statics, Applets & Delegation.
Creating Packages.
Using Packages.
static Methods.
static Variables.
Applications and Applets.
Event Delegation (optional).
APPENDIXES.
A. Intro to Computing Systems.
What is a Computer?
Analog or Digital?
How is Data Stored?
What are Binary Numbers?
How do Computers Communicate?
Why are Computers Called “Systems”?
B. Syntax Diagrams for Java.
C. Java Operator Precedence.
D. swing, awt & aLibrary.
Background on awt and swing.
Transitioning Common Features.
JFrame instead of Awindow.
JLabel instead of Alabel.
JComponent instead of AView, AOval, ARectangle and AroundRectangle.
JComponent instead of Aline.
JComponent instead of Aimage.
Event Delegation - Handling Mouse Events.
JButton instead of Abutton.
JScrollBar instead of Ascrollbar.
TextArea instead of AtextArea.
JTextField instead of AtextField.
E. UML Notations.
Class Diagrams.
Object Diagrams.
Activity Diagrams.
F. BlueJ Summary.
Installation and Configuration.
Working with Projects.
Working with Classes.
Testing and Debugging.
