Programming Concepts in Java (Web Edition) Publisher/ISBN/Ordering Information Description of Book Program Examples from Book Solutions Manual for Book Preface Table of Contents

Book Information

Book Description

By using classes provided with the textbook to simplify textual input and output, Programming Concepts in Java teaches the fundamentals of computer science without becoming mired in Java's complexities.

In doing so, it covers concepts such as input of data, control constructs, methods, classes and inheritance, strings, applets, arrays, records, algorithms for sorting, linked lists, and trees.

Recognizing that Java's popularity with students rests with its ability to produce graphics applications and applets as well as its association with the World Wide Web, Programming Concepts in Java also has chapters covering HTML, the creation of applets and GUI applications, as well as a chapter covering the details of the classes used earlier in the book.

Programming Concepts in Java comes with a disk containing a suite of tools and classes (Console, PrintFiles, PrettyPrint and others) as well as all of the example classes contained in the book.

Preface to Programming Concepts in Java (First Edition)

Programming Concepts in Java focuses on computing concepts with the ultimate goal of facilitating the broadest possible coverage of the core computer science curriculum. In an effort to provide material for courses covering the World Wide Web we have included an introductory chapter on creating web pages using HTML.

To begin, Java standalone application programs are used exclusively. Applets are covered in considerable detail in later chapters. Some of the more advanced notions of concurrency, exception handling, and graphical user interfaces have been omitted or are discussed in an abbreviated way.

This textbook package includes a disk containing a collection of Java classes to facilitate the teaching of Java. These include the Console class which enables students to do text and graphics I/O without having to master the intricacies of the Java Abstract Windowing Toolkit. In the last chapter of the book this Console class is presented in detail to show how such a large class is constructed using classes from the standard Java class library. The collection includes the Stdin class, which allows students to read all of Java's primitive data types from the standard input stream without having to master Java data type conversion. There are also classes for pretty printing (paragraphing) Java programs, reading Java primitive data types from text files, and submitting programs for marking. A complete set of the classes presented as examples in this book is also on the disk.

(Additional references should be consulted if a complete syntax of Java or the Java class libraries is required.)

Overview

The list of chapter titles outlines the arrangement of materials.

1. Programming Paradigms
2. Basic Programming Language Concepts
3. Input of Data
4. Control Constructs
5. Strings
6. Methods
7. Classes and Inheritance
8. Applets and Graphical User Interfaces
9. Creating Web Pages with HTML
10. Arrays
11. Records in Java
12. Algorithms for Sorting Lists
13. Self-Referential Classes and Linked Lists
14. Trees
15. Advanced GUIs
16. The Console Class

Chapter 2 presents the EBNF metalanguage for formally describing the syntax of a programming language. The primitive data types of the Java language are defined along with the way to declare variables of these types. Expressions for each type are also defined and the assignment statement presented. The chapter explains how values of the different types are output and formatted using the Console class. The role of comments in providing internal documentation to a program is also discussed.

Chapter 3 discusses how data can be input to a program. Ways in which a list of data items can be input by counted or conditional loops are shown. Input from the standard input, the keyboard, and input from a file are discussed. Ways to generate data using random numbers for purposes of testing programs are presented. The statistical analysis of numerical data is also described.

Chapter 4 deals with program structure. Algorithms can be programmed using three basic forms of control structure: linear sequence, repetition, and selection. The Java syntax for each of these is defined. The use of diagrams such as flow charts to supplement the program itself is discussed and shown to be unnecessary for a structured program which is properly paragraphed, and internally documented. Tracing execution of a program before trying to run it on a computer is encouraged

Chapter 5 introduces the String data structure which is implemented using the String class. Strings in Java are objects instantiated from the String class. Methods of the class are shown. The StringBuffer class is introduced as useful when the contents of a string are to be changed. The StringTokenizer class which permits the breaking of a string into tokens is illustrated.

Chapter 6 provides details about methods - components of a object that can be used by other objects to operate on the data of the original object. As with subprograms of earlier programming languages, methods fall into two principal classes: procedure-type methods that perform some action and function-type methods that yield a value. The differences in the way these two types of methods are defined and invoked is detailed. The relation between formal and actual parameters is explained. The scope of identifiers in a program is outlined. The signature, header, and specifications of a method are defined. Methods that call themselves (recursive methods) - and iterative methods that accomplish the same result - are dealt with.

Chapter 7 shows how an object can encapsulate data and the methods that operate on the data, and illustrates how other objects that use that object are prevented from interfering with the encapsulated data. The class is the template from which an object is instantiated. A constructor method of the class is used to create a new instance of the class - the object. Examples are given of using and creating a class. Inheritance is introduced as a means by which new classes are created through modifications of a base class. By using the Java library of classes, multiple objects of the class can be created or new classes produced.

Chapter 8 introduces Java applets. Applets are invoked by using a browser, such as Netscape Navigator, and can be accessed through the World Wide Web. It is this feature of Java that is at the root of much of its popularity, as well as its being an object-oriented programming language. Graphical User Interfaces (GUIs) are introduced. This chapter covers many of the classes in Java's Abstract Windowing Toolkit (awt).

Chapter 9 explores the creation of web pages using HTML (Hypertext Markup Language). The use of HTML to format information, create tables, place pictures, and display lists is discussed in some detail. The chapter also discusses the details controlling the presentation of an applet: its size, location on the screen, and so on.

Chapter 10 introduces the structured data type called an array. Individual elements of an array share the same name and data type but are distinguished from each other by having an index. An individual element of an array can be passed by value to a method whereas an entire array is passed, as any object is, by reference. When the method alters its array parameter the actual array is altered. The efficiencies of searching an array by a linear search and a sorted array by a binary search are compared.

Chapter 11 describes implementing records as objects and the reading from and writing to binary files. In Java, there is no standard way to store an object's fields in a record. As a result, it must be programmed The ways records can be input from or output to a file are shown, as is the storage of records in a binary form so that random access to individual records is possible. A simple linear search of an array of records is introduced as an example of using records.

Chapter 12 presents algorithms for sorting lists of data stored in arrays. The time complexity of sorting algorithms is explored and big O notation introduced. The chapter also explains how methods depending on recursion prove to be more efficient than simple exchange algorithms.

Chapter 13 gives details of self-referential classes and how they can be used to instantiate nodes to link objects together in simple linked lists. A List class is created and then modified to produce an OrderedList class by inheritance.

Chapter 14 introduces the binary tree as a data structure that has a recursive definition and is easily implemented by having two links in a node. The chapter demonstrates how the efficiency of searching achieved with a sorted array using a binary search, and the ease of insertion and deletion of elements in a linear linked list is possible with a binary search tree. The heap sort is introduced as a recursive method of sorting which uses trees defined somewhat differently than binary search trees.

Chapter 15 introduces many of the more advanced features of the graphical interface capabilities of Java's Abstract Windowing Toolkit (awt) by guiding students through the construction of a movie ticket seller applet and a simple paint applet.

Chapter 16 provides a detailed example of building a graphical user interface. It examines a simplified version of the HSA Console class to further explore Java's Abstract Windowing Toolkit.

Conventions

• All identifiers that are multiple words use an upper case letter to begin all words after the first
• Class names have the first letter capitalized.
• Variable and method names have identifiers beginning with a lower case letter.
• Constants have identifiers all in upper case.

Flexibility

Differing course demands and student populations may require instructors to omit certain chapters or parts of chapters, or to insert additional material to cover some concepts in greater detail. For example, the discussion of algorithm complexity and big O notation can easily be omitted from the course of study. The instructor may wish to provide other resources if more than an introduction to program correctness or the use of Java on the Internet is desired.

The Java Programming Language

The language is portable; it can be used on any computer platform that has a Java interpreter. This means that software developers can confidently program in Java and know that their software will run on any such computer. As well, individuals can also share applets via the Web. Attempts are made to make the use of shared programs safe. For security, for example, no applet may read from or write to a file on the system on which it is being executed.

Java syntax is based on the C syntax but many of the difficult and error prone parts of C and C++, such as pointers, operator overloading, and multiple inheritance have been eliminated. In this book we have eliminated still more of the "tricks" that some C programmers delight in. Our approach is based on the fundamental principle of structured programming, namely keeping programs easy to understand.

Java and its class libraries have many additional features which are not part of C or C++. It provides for strings, graphics, concurrency, and exception handling, as well as a large number of data structures in its class libraries. Java also provides graphical user interface classes.

All of these features contribute to Java's attractiveness as both a commercial software tool and a means of addressing the core computer science concepts.

Table of Contents of Programming Concepts in Java