9780131471061

KEY BENEFIT: Based on his inspiring lecture style, author Frank Carranors"s new text,Imagine! Java, engages readers immediately with vivid everyday examples and analogies that help them understand abstract programming concepts. Frank keeps readers interested by presenting material in short, manageable segments that build on the topic at hand. KEY TOPICS: A First Look at Java; Arithmetic Expressions; Using Classes and Objects; Basic Graphics; Class Definitions: The Fundamentals; Decisions; Class Definitions: More Details; Classes of Graphical Objects; Multiway Decisions; Decisions when Drawing; Repetition; Repetition Continued; Repetition when Drawing; Designing Classes; Design Concepts; Inheritance and Interfaces in Swing and the AWT; Arrays; An Array-Based Data Structure; Arrays Continued; Array Lists; Arrays when Drawing; Sorting and Searching; Recursion; Recursive Array Processing; Recursive Drawings; Inheritance Continued; Exceptions; Text Files; Sequential Binary Files; Random-Access Files; Generics and Data Structures. MARKET: Ideal for anyone interested in an introduction to the Java language.

Frank M. Carrano is a professor emeritus of computer science at the University of Rhode Island. He received the Ph.D. degree in computer science from Syracuse University in 1969. His interests include data structures, computer science education, social issues in computing, and numerical computation. Professor Carrano is particularly interested in the design and delivery of undergraduate courses in computer science. He has authored several well-known computer science textbooks for undergraduates.

Frank’s Making it Real blog http://frank-m-carrano.com/blog/ extends his textbooks and lectures to a lively discussion with instructors and students about teaching and learning computer science.

Follow Frank on Twitter: http://twitter.com/Frank_M_Carrano

Find him on Facebook: https://www.facebook.com/makingitreal

TABLE OF CONTENTS

1. Introduction

An Overview of a Computer

What Can a Computer Do?

The Components of a Typical Computer

A Computing System’s Software

The Programming Language Java

Graphics

Writing, Compiling, and Running a Java Program

Tools and Resources

The Steps

2. A First Look at Java

A Simple Java Program

Identifiers

Displaying Text

Comments

Data Types

Primitive Types

Reference Types

Variables

Declarations

Assignments

Constants

Unnamed Constants

Named Constants

Simple Input from the Keyboard

A Problem Solved: Apples by the Box

3. Arithmetic Expressions

Arithmetic Operators

The Addition and Subtraction Operators, + and -

The Multiplication Operator *

The Division Operator /

The Remainder Operator %

The Order of Operations

Conversions Between Numeric Data Types

Coercion

Casting

A Problem Partially Solved: Day of the Week

Standard Mathematical Methods

A Problem Solved: Wind Chill

Debugging Interlude 1 : The Errors Made by Programmers

Kinds of Errors

Compile-Time Errors

Execution-Time Errors

4. Using Classes and Objects

Introduction

The Class String

References

Characters Within Strings

Joining Strings

String Methods

Comparing Characters and Strings

Using Scanner to Read a String

A Problem Solved: Processing a String

Using Scanner to Extract Pieces of a String

Immutable Strings

The Class Date

The Class BigDecimal

A Problem Solved: More Apples by the Box

Wrapper Classes

The Class Random

The Class DecimalFormat

The Class JOptionPane

Using a Dialog Box to Read or Write a String

5. Basic Graphics

Creating a Window

Getting Ready to Draw

A Sample Drawing Panel

Displaying a Panel

The Class Graphics

The Coordinate System

Drawing Lines, Shapes, and Text

Painting Shapes

A Problem Solved: Displaying a Temperature

The Class Font

The Class Color

A Problem Solved: The Happy Face

6. Class Definitions: The Fundamentals

A Class Definition

Using the Class Greeter

Beginning the Class Definition

Defining Constructors

Defining Other Methods

Local Variables

Creating a New Class

The Design

The Implementation

Passing Arguments

A Problem Solved: Comparing Classes of Squares

Debugging Interlude 2 : Common Mistakes When Working with Classes

Working with Classes

A Silent Computational Error

Undefined Variables of a Class Type

Constructors

Omitting the Method toString

A Problem Solved: Extracting Strings

7. Decisions

Flow of Control

The if Statement

Compound Statements

Basic Comparisons

Comparing Primitives

Comparing Objects

A Problem Solved: Day of the Week

The if-else Statement

More Boolean Expressions in Comparisons

A Problem Solved: Leap Years

Assertions

8. Class Definitions: More Details

Boolean-Valued Methods

Private Methods

Checking the Validity of Data Fields

Final Fields and Static Final Fields

Enumerations

A Problem Solved: Representing Coins

A Simpler Problem: A Class of Valueless Coins

Enhancing the Class Definition

Calling a Constructor from a Constructor

9. Classes of Graphical Objects

A Problem Solved: The Happy Face Reprised

The Class HappyFace: First Version

The Class HappyFace: Improved Version

A Problem Solved: The Thermometer Reprised

The Class Thermometer

Displaying the Thermometer

Displaying Two Thermometers

10. Multiway Decisions

Nested if Statements

A Problem Solved: Health Club Welcome

The switch Statement

A Problem Solved: Where To?

A Problem Solved: Representing a Temperature

11. Decisions and Object Interaction when Drawing

A Problem Solved: The Thermometer Yet Again

A Problem Solved: Displaying a Random Color

A Problem Solved: Displaying a Row of Dots

A Problem Solved: Where Is the Random Point?

Debugging Interlude 3: Introduction to Testing

Avoiding Mistakes

Displaying a Calendar

A Problem Solved: The Café Sign

Comparing Two Solutions

12. Repetition

The Logic of a Loop

The while Statement

A Problem Solved: A Guessing Game

Errors in Loops

Off-by-One Errors

Infinite Loops

Boolean Variables in Loops

Nested Loops

The Scope of a Variable

A Problem Solved: Root of an Equation

13. Repetition Continued

The for Statement

Using an Enumeration with a for Statement

The do Statement

14. Repetition when Drawing

A Problem Solved: Displaying a Row of Dots (Reprise)

A Problem Solved: The Quahog Shell

A Problem Solved: Circles and Squares

A Problem Solved: The Quilt

A Problem Solved: A Random Walk

Debugging Interlude 4: Debugging Loops

Testing

Debugging Loops

An Example

Overview of Debugging Tools

The Command-Line Tool jdb (Optional)

15. Designing Classes

Design Tools

Choosing Classes

CRC Cards

The Unified Modeling Language

Specifying Methods

Abstraction and Encapsulation

Comments

Preconditions and Postconditions

A Problem Solved: Creating a Class to Represent People

A Class Design

A Client for Person

Implementation of the Class Person

Overloaded Methods

Class Relationships

Reusing Classes

Coupling and Cohesion

The Modifier static

Static Fields

Static Methods

An Enumeration as a Class

16. Object-Oriented Concepts

Java Interfaces

Writing an Interface

Some UML Details

Implementing an Interface

An Interface as a Data Type

Casting and Interfaces

Polymorphism and Interfaces

Inheritance Basics

The Class Object

Overriding the Method equals

Polymorphism and Inheritance

Extending an Interface

The Comparable Interface

17. Inheritance and Interfaces in Swing and the AWT

The Organization of Major Classes Within the AWT and Swing

Using Button Input

The Class JButton

Implementing the Interface ActionListener

Registering an Action Listener

Responding to a Button Click

A Problem Solved: Smile or Frown

Using Mouse Input

The Interface MouseListener

A Problem Solved: Changing Color at the Click of a Mouse

The Interface MouseMotionListener

Using Text Fields

The Class JTextField

A Problem Solved: Displaying RGB Colors

Debugging Interlude 5: Debugging Tools

Using Breakpoints and Watches in an IDE

Logging

The Class Logger

An Example

More Logging (Optional)

Message Levels

Other Logger Methods

Logging Messages at Levels Lower Than INFO

A Problem Debugged: The Click Disc

18. Arrays

Motivation

Array Basics

Declaring and Creating an Array

Declaring and Initializing an Array

Referencing Array Elements

Array Index Out of Bounds

Examples of Processing an Array

Computing Deviations

Partially Filled Arrays

Counting Occurrences in an Array

Finding the Smallest Entry in an Array

Finding the Index of the Smallest Entry in an Array

Searching an Array for a Given Entry

More Fundamentals

Arrays of Objects

Passing an Array to a Method

Array Assignments

Copying an Array

Methods that Return an Array

Array Equality

Time Out

19. An Array-Based Data Structure

The Bag

A Bag’s Behaviors

Specifying a Bag

An Interface

Implementing and Testing a Bag

A Group of Core Methods

Implementing More Methods

Methods That Remove Strings

The Class Definition

20. Arrays Continued

More About One-Dimensional Arrays

The For-Each Loop Applied to Arrays

Resizing an Array

A Problem Solved: An Expandable Bag

An Arbitrary Number of Arguments

The Parameter in the Method main

Multidimensional Arrays

The Basics

Java’s Representation

A Problem Solved: Processing a Digital Image

Arrays of Three or More Dimensions

Ragged Arrays

Parallel Arrays

Debugging Interlude 6 : Debugging Arrays

An Unallocated Array

A Silent Error

The Method toArray as a Stub

Array Index Out of Bounds

Defining the Method toArray

Another Silent Error

The Method remove

21. Array Lists

The List

The Behaviors of a List

The Interface List

The Class ArrayList

An Array List’s Size and Capacity

Creating an Array List

Adding Entries to a List

Retrieving Entries

Searching for Entries

Replacing Entries

Removing Entries

Arrays Versus Array Lists

22. Arrays when Drawing

Polygons

Polygon Methods in the Class Graphics

The Class Polygon

A Class of Right Triangles

Data Fields and Methods

The Class Point

Specifications for the Class RightTriangle

Implementing RightTriangle

A Problem Solved: A New Quilt

A Class of Squares

A Class of Quilts

A Problem Solved: Connecting the Dots

Using Parallel Arrays of Coordinates

Using an Array of Points

Using a List of Points

A Problem Solved: The Keypad

Establishing the Design

The Class OutputPanel

The Class KeypadPanel

The Class KeypadDriver

23. Sorting and Searching

Sorting

Selection Sort

Detecting When an Array Is Sorted

Insertion Sort

Sorting Objects

Sorting Methods in the Java Class Library

Searching

A Linear Search of an Unsorted Array

A Linear Search of a Sorted Array

A Binary Search of a Sorted Array

Searching Methods in the Java Class Library

The Performance of Algorithms

The Performance of Sorting Methods

The Performance of Searching Methods

24. Recursion

What Is Recursion?

Example: The Countdown

Implementation Details

Tracing a Recursive Method

Recursive Methods That Return a Value

A Problem Solved: Speaking the Digits in a Number

A Problem Solved: Writing a Number in Words

Recursion Versus Iteration

Fibonacci Numbers: A Poor Use of Recursion

Kinds of Recursion

Tail Recursion

Direct, Indirect, and Mutual Recursion

25. Recursive Array Processing

Basic Techniques

Searching an Array Recursively

A Recursive Linear Search

Searching a Bag Recursively

A Recursive Binary Search

A Recursive Merge Sort

Merging Arrays

The Merge Sort Algorithm

A Merge Sort Method

Merge Sort in the Java Class Library

The Performance of Merge Sort (Optional)

Recursion Versus Iteration

Binary Search

Merge Sort

26. Recursive Drawings

A Problem Solved: The Target

A Problem Solved: Painting Like Mondrian

A Problem Solved: The Sierpinski Carpet

Debugging Interlude 7 : Debugging Recursive Methods

Infinite Recursion

Carpeting Trouble: Base-Case Omission

Incorrect Results

Sorting and Merging, Merging and Sorting

Verbalizing Integers: Saying Too Much

27. Inheritance Continued

A Problem Solved: Designing a Hierarchy of Classes

The Basic Rules of Inheritance

What Is Inherited?

Constructors of the Superclass and Subclass

Protected Access

The Implementation So Far

Packages and Package Access

Type Compatibility

Casting Object Types

Abstract Classes and Methods

Interfaces Versus Abstract Classes

Overriding Methods, Hiding Methods

Overriding Revisited

Hiding Methods

Final Classes and Methods

28. Exceptions

The Basics

Kinds of Exceptions

Errors

Handling an Exception

Postpone Handling: The throws Clause

Handle It Now: The try-catch Blocks

Multiple catch Blocks

Throwing an Exception

Programmer Defined Exception Classes

A Sample Definition

Using Our Own Exception Class

A Problem Solved: Groups of People

Inheritance and Exceptions

The finally Block

29. Text Files

Preliminaries

Why Files?

Streams

The Kinds of Files

File Names

Creating a Text File

Opening, Writing, and Closing a Text File

A Class for Creating Text Files

A Problem Solved: Creating a Text File of Colleges and Universities

Reading a Text File

Opening, Reading, and Closing a Text File

A Problem Solved: Displaying a List of Colleges and Universities

Reading a Text File More Than Once

Appending Data to an Existing Text File

Changing Existing Data in a Text File

ONLINE CHAPTERS

30. Sequential Binary Files

Creating a Binary File of Objects

Opening, Writing, and Closing a Binary File

A Class for Creating a Binary File of Objects

A Problem Solved: Creating a Binary File of Colleges and Universities

Reading a Binary File of Objects

Opening, Reading, and Closing a Binary File

A Problem Solved: Displaying a List of Colleges and Universities

Arrays in Binary Files

Writing Arrays to a Binary File

Reading Arrays From a Binary File

Binary Files of Primitive Data

Writing Primitive Data to a Binary File

Reading Primitive Data From a Binary File

31. Random-Access Files

The File Pointer

Basic Operations for a Random Access File

Opening a Random-Access File

Writing to a Random-Access File

Reading a Random-Access File

Recording File-Pointer Values

A Problem Solved: A Glossary of Terms

Creating the Glossary

Accessing the Glossary

32. Generics and Collections

Generics

Generic Types Within a Class Definition

Generic Types Within an Interface

A Problem Solved: A Bag of Objects

Collections

Abstract Data Types

Data Structures

The Java Collections Framework

APPENDICES

A. Getting Java for Free

B. Reserved Words

C. Unicode Characters

D. Documentation and Programming Style

Naming Variables and Classes

Indenting

Comments

Single-Line Comments

Comment Blocks

When to Write Comments

Java Documentation Comments

Running javadoc

E. Cloning

Cloning an Object

Cloning an Array

Glossary

Index

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 access cards, study guides, lab manuals, CDs, etc.

The Used, Rental and eBook copies of this book are not guaranteed to include any supplemental materials. Typically, only the book itself is included. This is true even if the title states it includes any access cards, study guides, lab manuals, CDs, etc.

Welcome to the first edition ofImagine Java!,a new book for an introductory course in Java programming, typically known as CS-1. A New ApproachThis book makes learning easier by focusing your attention on one issue at a time, by offering an optional yet integrated coverage of graphics, and by providing flexibility in the order in which you can cover topics. To accomplish these goals, the material is divided into short, numbered segments that are organized into 25 relatively short chapters. Each segment presents a single idea and individual chapters focus on specific aspects of Java. Graphical applications and applets appear in their own optional chapters and are integrated into the text to illustrate aspects of Java just presented. Thus, the graphics coverage augments and enhances the learning experience instead of being presented for its own sake. A dependency chart appears later in this preface to help you plan your path through the book.This book was created specifically with objects and Java in mind. Objects are introduced early and are used in the demonstrations of Java fundamentals. New features of Java 1.5--including the class scanner--are integrated into the text at appropriate points. After readers understand how to use objects, they learn how to write classes. Interface, inheritance, and polymorphism are presented midway through the book and then covered in more depth in later chapters.Questions throughout each chapter elaborate the presentation and further the reader's understanding of the material. Answers to these questions appear in an appendix. Further practice is available by solving the exercises and programming projects at the end of each chapter. Features 25 relatively short chapters can be covered in several orders. Short, bite-sized segments focus attention on one issue at a time. Separate and optional chapters about graphics illustrate Java features and are integrated into the overall presentation. Debugging interludes occur after key chapters to discuss debugging and testing. Material is introduced in the context of a problem to be solved. Many examples illustrate new concepts. Complete programs provide a context for the Java features presented. Highlighted notes emphasize key material and provide supplementary comments. Programming tips give additional programming advice. Numerous figures make the presentation visual and accessible. Questions throughout the book--and their answers--elaborate on the material presented. Java code includes javadoc comments. Appendices provide supplementary material about Java. A glossary defines new terms. Java's reserved words, the precedence of its operators, and a summary of statements appear inside the front and back covers. A Prentice Hall Companion Website at www.prenhall.com/carrano provides the Java code that appears in the book as well as any updates or corrections. Supplements for instructors include PowerPoint slides, laboratory materials, and answers to selected exercises and programming projects. A Note to StudentsAfter looking over this preface, you should see what is available in the appendices as well as inside the front and back covers. Note in particular the glossary of terms and the answers to the questions that appear throughout each chapter. These questions should help you to understand the material. Each chapter begins with a table of contents and a list of prerequisite chapters that you should have read. Each chapter ends with a summary of what was covered. All of the Java code that appears in this book is available for download from the book's companion website at www.prenhall.com/carrano . This website also contains any u

Amazon no longer offers textbook rentals. We do!

Imagine! Java Programming Concepts in Context

Imagine! Java Programming Concepts in Context

0131471066

Summary

Author Biography

Table of Contents

Supplemental Materials

Excerpts

Write a Review