Notes about Java and Java How to Program, Sixth Edition
Java is a powerful programming language. Experienced programmers sometimes take pride in creating weird, contorted, convoluted usage of a language. This is a poor programming practice. It makes programs more difficult to read, more likely to behave strangely, more difficult to test and debug, and more difficult to adapt to changing requirements. This book stresses clarity. The following is our first "good programming practice" tip.
Good Programming Practice 1.1
 |
Write your Java programs in a simple and straightforward manner. This is sometimes referred to as KIS ("keep it simple"). Do not "stretch" the language by trying bizarre usages. |
You have heard that Java is a portable language and that programs written in Java can run on many different computers. For programming in general, portability is an elusive goal. The ANSI C standard document (located at www.ansi.org), which describes the C programming language, contains a lengthy list of portability issues. In fact, whole books have been written to discuss portability, such as Rex Jaeschke's Portability and the C Language.
Portability Tip 1.2
 |
Although it is easier to write portable programs in Java than in other programming languages, differences between compilers, JVMs and computers can make portability difficult to achieve. Simply writing programs in Java does not guarantee portability. |
Error-Prevention Tip 1.1
 |
Always test your Java programs on all systems on which you intend to run them, to ensure that they will work correctly for their intended audiences. |
We have audited our presentation against Sun's current Java documentation for completeness and accuracy. However, Java is a rich language, and no textbook can cover every topic. A Web-based version of the Java API documentation can be found at java.sun.com/j2se/5.0/docs/api/index.html or you can download this documentation to your own computer from java.sun.com/j2se/5.0/download.html. For additional technical details on Java, visit java.sun.com/reference/docs/index.html. This site provides detailed information about many aspects of Java development, including all three Java platforms.
Good Programming Practice 1.2
|
Read the documentation for the version of Java you are using. Refer to it frequently to be sure you are aware of the rich collection of Java features and are using them correctly. |
Good Programming Practice 1.3
|
Your computer and compiler are good teachers. If, after carefully reading your Java documentation manual, you are not sure how a feature of Java works, experiment and see what happens. Study each error or warning message you get when you compile your programs (called compile-time errors or compilation errors), and correct the programs to eliminate these messages. |
Software Engineering Observation 1.4
 |
The J2SE Development Kit comes with the Java source code. Some programmers like to read the source code for the Java API classes to determine how the classes work and to learn additional programming techniques. |
Introduction to Computers, the Internet and the World Wide Web
- Introduction
- What Is a Computer?
- Computer Organization
- Early Operating Systems
- Personal, Distributed and Client/Server Computing
- The Internet and the World Wide Web
- Machine Languages, Assembly Languages and High-Level Languages
- History of C and C++
- History of Java
- Java Class Libraries
- FORTRAN, COBOL, Pascal and Ada
- BASIC, Visual Basic, Visual C++, C# and .NET
- Typical Java Development Environment
- Notes about Java and Java How to Program, Sixth Edition
- Test-Driving a Java Application
- Software Engineering Case Study: Introduction to Object Technology and the UML (Required)
- Wrap-Up
- Web Resources
- Summary
- Terminology
- Self-Review Exercises
- Exercises
Introduction to Java Applications
- Introduction
- First Program in Java: Printing a Line of Text
- Modifying Our First Java Program
- Displaying Text with printf
- Another Java Application: Adding Integers
- Memory Concepts
- Arithmetic
- Decision Making: Equality and Relational Operators
- (Optional) Software Engineering Case Study: Examining the Requirements Document
- Wrap-Up
- Summary
- Terminology
- Self-Review Exercises
- Exercises
Introduction to Classes and Objects
- Introduction
- Classes, Objects, Methods and Instance Variables
- Declaring a Class with a Method and Instantiating an Object of a Class
- Declaring a Method with a Parameter
- Instance Variables, set Methods and get Methods
- Primitive Types vs. Reference Types
- Initializing Objects with Constructors
- Floating-Point Numbers and Type double
- (Optional) GUI and Graphics Case Study: Using Dialog Boxes
- (Optional) Software Engineering Case Study: Identifying the Classes in a Requirements Document
- Wrap-Up
- Summary
- Terminology
- Self-Review Exercises
- Exercises
Control Statements: Part I
- Introduction
- Algorithms
- Pseudocode
- Control Structures
- if Single-Selection Statement
- if...else Double-Selection Statement
- while Repetition Statement
- Formulating Algorithms: Counter-Controlled Repetition
- Formulating Algorithms: Sentinel-Controlled Repetition
- Formulating Algorithms: Nested Control Statements
- Compound Assignment Operators
- Increment and Decrement Operators
- Primitive Types
- (Optional) GUI and Graphics Case Study: Creating Simple Drawings
- (Optional) Software Engineering Case Study: Identifying Class Attributes
- Wrap-Up
- Summary
- Terminology
- Self-Review Exercises
- Exercises
Control Statements: Part 2
- Introduction
- Essentials of Counter-Controlled Repetition
- for Repetition Statement
- Examples Using the for Statement
- do...while Repetition Statement
- switch Multiple-Selection Statement
- break and continue Statements
- Logical Operators
- Structured Programming Summary
- (Optional) GUI and Graphics Case Study: Drawing Rectangles and Ovals
- (Optional) Software Engineering Case Study: Identifying Objects States and Activities
- Wrap-Up
- Summary
- Terminology
- Self-Review Exercises
- Exercises
Methods: A Deeper Look
- Introduction
- Program Modules in Java
- static Methods, static Fields and Class Math
- Declaring Methods with Multiple Parameters
- Notes on Declaring and Using Methods
- Method Call Stack and Activation Records
- Argument Promotion and Casting
- Java API Packages
- Case Study: Random-Number Generation
- Case Study: A Game of Chance (Introducing Enumerations)
- Scope of Declarations
- Method Overloading
- (Optional) GUI and Graphics Case Study: Colors and Filled Shapes
- (Optional) Software Engineering Case Study: Identifying Class Operations
- Wrap-Up
- Summary
- Terminology
- Self-Review Exercises
- Exercises
Arrays
- Introduction
- Arrays
- Declaring and Creating Arrays
- Examples Using Arrays
- Case Study: Card Shuffling and Dealing Simulation
- Enhanced for Statement
- Passing Arrays to Methods
- Case Study: Class GradeBook Using an Array to Store Grades
- Multidimensional Arrays
- Case Study: Class GradeBook Using a Two-Dimensional Array
- Variable-Length Argument Lists
- Using Command-Line Arguments
- (Optional) GUI and Graphics Case Study: Drawing Arcs
- (Optional) Software Engineering Case Study: Collaboration Among Objects
- Wrap-Up
- Summary
- Terminology
- Self-Review Exercises
- Exercises
- Special Section: Building Your Own Computer
Classes and Objects: A Deeper Look
- Introduction
- Time Class Case Study
- Controlling Access to Members
- Referring to the Current Objects Members with the this Reference
- Time Class Case Study: Overloaded Constructors
- Default and No-Argument Constructors
- Notes on Set and Get Methods
- Composition
- Enumerations
- Garbage Collection and Method finalize
- static Class Members
- static Import
- final Instance Variables
- Software Reusability
- Data Abstraction and Encapsulation
- Time Class Case Study: Creating Packages
- Package Access
- (Optional) GUI and Graphics Case Study: Using Objects with Graphics
- (Optional) Software Engineering Case Study: Starting to Program the Classes of the ATM System
- Wrap-Up
- Summary
- Terminology
- Self-Review Exercises
- Exercises
Object-Oriented Programming: Inheritance
- Introduction
- Superclasses and Subclasses
- protected Members
- Relationship between Superclasses and Subclasses
- Constructors in Subclasses
- Software Engineering with Inheritance
- Object Class
- (Optional) GUI and Graphics Case Study: Displaying Text and Images Using Labels
- Wrap-Up
- Summary
- Terminology
- Self-Review Exercises
- Exercises
Object-Oriented Programming: Polymorphism
- Introduction
- Polymorphism Examples
- Demonstrating Polymorphic Behavior
- Abstract Classes and Methods
- Case Study: Payroll System Using Polymorphism
- final Methods and Classes
- Case Study: Creating and Using Interfaces
- (Optional) GUI and Graphics Case Study: Drawing with Polymorphism
- (Optional) Software Engineering Case Study: Incorporating Inheritance into the ATM System
- Wrap-Up
- Summary
- Terminology
- Self-Review Exercises
- Exercises
GUI Components: Part 1
- Introduction
- Simple GUI-Based Input/Output with JOptionPane
- Overview of Swing Components
- Displaying Text and Images in a Window
- Text Fields and an Introduction to Event Handling with Nested Classes
- Common GUI Event Types and Listener Interfaces
- How Event Handling Works
- JButton
- Buttons that Maintain State
- JComboBox and Using an Anonymous Inner Class for Event Handling
- JList
- Multiple-Selection Lists
- Mouse Event Handling
- Adapter Classes
- JPanel Subclass for Drawing with the Mouse
- Key-Event Handling
- Layout Managers
- Using Panels to Manage More Complex Layouts
- JTextArea
- Wrap-Up
- Summary
- Terminology
- Self-Review Exercises
- Exercises
Graphics and Java 2D™
- Introduction
- Graphics Contexts and Graphics Objects
- Color Control
- Font Control
- Drawing Lines, Rectangles and Ovals
- Drawing Arcs
- Drawing Polygons and Polylines
- Java 2D API
- Wrap-Up
- Summary
- Terminology
- Self-Review Exercises
- Exercises
Exception Handling
- Introduction
- Exception-Handling Overview
- Example: Divide By Zero Without Exception Handling
- Example: Handling ArithmeticExceptions and InputMismatchExceptions
- When to Use Exception Handling
- Java Exception Hierarchy
- finally block
- Stack Unwinding
- printStackTrace, getStackTrace and getMessage
- Chained Exceptions
- Declaring New Exception Types
- Preconditions and Postconditions
- Assertions
- Wrap-Up
- Summary
- Terminology
- Self-Review Exercises
- Exercises
Files and Streams
- Introduction
- Data Hierarchy
- Files and Streams
- Class File
- Sequential-Access Text Files
- Object Serialization
- Random-Access Files
- Additional java.io Classes
- Opening Files with JFileChooser
- Wrap-Up
- Summary
- Terminology
- Self-Review Exercises
- Exercises
Recursion
- Introduction
- Recursion Concepts
- Example Using Recursion: Factorials
- Example Using Recursion: Fibonacci Series
- Recursion and the Method Call Stack
- Recursion vs. Iteration
- String Permutations
- Towers of Hanoi
- Fractals
- Recursive Backtracking
- Wrap-Up
- Internet and Web Resources
- Summary
- Terminology
- Self-Review Exercises
- Exercises
Searching and Sorting
- Introduction
- Searching Algorithms
- Sorting Algorithms
- Invariants
- Wrap-up
- Summary
- Terminology
- Self-Review Exercises
- Exercises
Data Structures
- Introduction
- Type-Wrapper Classes for Primitive Types
- Autoboxing and Auto-Unboxing
- Self-Referential Classes
- Dynamic Memory Allocation
- Linked Lists
- Stacks
- Queues
- Trees
- Wrap-Up
- Summary
- Terminology
- Self-Review Exercises
- Exercises
- Special Section: Building Your Own Compiler
Generics
- Introduction
- Motivation for Generic Methods
- Generic Methods: Implementation and Compile-Time Translation
- Additional Compile-Time Translation Issues: Methods That Use a Type Parameter as the Return Type
- Overloading Generic Methods
- Generic Classes
- Raw Types
- Wildcards in Methods That Accept Type Parameters
- Generics and Inheritance: Notes
- Wrap-Up
- Internet and Web Resources
- Summary
- Terminology
- Self-Review Exercises
- Exercises
Collections
- Introduction
- Collections Overview
- Class Arrays
- Interface Collection and Class Collections
- Lists
- Collections Algorithms
- Stack Class of Package java.util
- Class PriorityQueue and Interface Queue
- Sets
- Maps
- Properties Class
- Synchronized Collections
- Unmodifiable Collections
- Abstract Implementations
- Wrap-Up
- Summary
- Terminology
- Self-Review Exercises
- Exercises
Introduction to Java Applets
- Introduction
- Sample Applets Provided with the JDK
- Simple Java Applet: Drawing a String
- Applet Life-Cycle Methods
- Initializing an Instance Variable with Method init
- Sandbox Security Model
- Internet and Web Resources
- Wrap-Up
- Summary
- Terminology
- Self-Review Exercises
- Exercises
Multimedia: Applets and Applications
- Introduction
- Loading, Displaying and Scaling Images
- Animating a Series of Images
- Image Maps
- Loading and Playing Audio Clips
- Playing Video and Other Media with Java Media Framework
- Wrap-Up
- Internet and Web Resources
- Summary
- Terminology
- Self-Review Exercises
- Exercises
- Special Section: Challenging Multimedia Projects
GUI Components: Part 2
- Introduction
- JSlider
- Windows: Additional Notes
- Using Menus with Frames
- JPopupMenu
- Pluggable Look-and-Feel
- JDesktopPane and JInternalFrame
- JTabbedPane
- Layout Managers: BoxLayout and GridBagLayout
- Wrap-Up
- Summary
- Terminology
- Self-Review Exercises
- Exercises
Multithreading
- Introduction
- Thread States: Life Cycle of a Thread
- Thread Priorities and Thread Scheduling
- Creating and Executing Threads
- Thread Synchronization
- Producer/Consumer Relationship without Synchronization
- Producer/Consumer Relationship with Synchronization
- Producer/Consumer Relationship: Circular Buffer
- Producer/Consumer Relationship: ArrayBlockingQueue
- Multithreading with GUI
- Other Classes and Interfaces in java.util.concurrent
- Monitors and Monitor Locks
- Wrap-Up
- Summary
- Terminology
- Self-Review Exercises
- Exercises
Networking
- Introduction
- Manipulating URLs
- Reading a File on a Web Server
- Establishing a Simple Server Using Stream Sockets
- Establishing a Simple Client Using Stream Sockets
- Client/Server Interaction with Stream Socket Connections
- Connectionless Client/Server Interaction with Datagrams
- Client/Server Tic-Tac-Toe Using a Multithreaded Server
- Security and the Network
- Case Study: DeitelMessenger Server and Client
- Wrap-Up
- Summary
- Terminology
- Self-Review Exercises
- Exercises
Accessing Databases with JDBC
- Introduction
- Relational Databases
- Relational Database Overview: The books Database
- SQL
- Instructions to install MySQL and MySQL Connector/J
- Instructions on Setting MySQL User Account
- Creating Database books in MySQL
- Manipulating Databases with JDBC
- Stored Procedures
- RowSet Interface
- Wrap-Up
- Internet and Web Resources
- Recommended Readings
- Summary
- Terminology
- Self-Review Exercises
- Exercises
Servlets
- Introduction
- Servlet Overview and Architecture
- Setting Up the Apache Tomcat Server
- Handling HTTP get Requests
- Handling HTTP get Requests Containing Data
- Handling HTTP post Requests
- Redirecting Requests to Other Resources
- Multitier Applications: Using JDBC from a Servlet
- Welcome Files
- Wrap-Up
- Internet and Web Resources
- Summary
- Terminology
- Self-Review Exercises
- Exercises
JavaServer Pages (JSP)
- Introduction
- JavaServer Pages Overview
- First JSP Example
- Implicit Objects
- Scripting
- Standard Actions
- Directives
- Case Study: Guest Book
- Wrap-Up
- Internet and Web Resources
- Summary
- Terminology
- Self-Review Exercises
- Exercises
Formatted Output
- Introduction
- Streams
- Formatting Output with printf
- Printing Integers
- Printing Floating-Point Numbers
- Printing Strings and Characters
- Printing Dates and Times
- Other Conversion Characters
- Printing with Field Widths and Precisions
- Using Flags in the printf Format String
- Printing with Argument Indices
- Printing Literals and Escape Sequences
- Formatting Output with Class Formatter
- Wrap-Up
- Summary
- Terminology
- Self-Review Exercises
- Exercises
Strings, Characters and Regular Expressions
- Introduction
- Fundamentals of Characters and Strings
- Class String
- Class StringBuffer
- Class Character
- Class StringTokenizer
- Regular Expressions, Class Pattern and Class Matcher
- Wrap-Up
- Summary
- Terminology
- Self-Review Exercises
- Exercises
- Special Section: Advanced String-Manipulation Exercises
- Special Section: Challenging String-Manipulation Projects
Appendix A. Operator Precedence Chart
Appendix B. ASCII Character Set
Appendix C. Keywords and Reserved Words
Appendix D. Primitive Types
Appendix E. (On CD) Number Systems
Appendix F. (On CD) Unicode®
Appendix G. Using the Java API Documentation
Appendix H. (On CD) Creating Documentation with javadoc
Appendix I. (On CD) Bit Manipulation
Appendix J. (On CD) ATM Case Study Code
Appendix K. (On CD) Labeled break and continue Statements
Appendix L. (On CD) UML 2: Additional Diagram Types
Appendix M. (On CD) Design Patterns
Appendix N. Using the Debugger
Inside Back Cover
EAN: 2147483647
Pages: 615
