You are previewing THE Java™ Programming Language, Fourth Edition.
O'Reilly logo
THE Java™ Programming Language, Fourth Edition

Book Description

Direct from the creators of the Java™ programming language, the completely revised fourth edition of The Java™ Programming Language is an indispensable resource for novice and advanced programmers alike.

Developers around the world have used previous editions to quickly gain a deep understanding of the Java programming language, its design goals, and how to use it most effectively in real-world development. Now, Ken Arnold, James Gosling, and David Holmes have updated this classic to reflect the major enhancements in Java™ 2 Standard Edition 5.0 (J2SE™ 5.0).

The authors systematically cover most classes in Java’s main packages, java.lang.*, java.util, and java.io, presenting in-depth explanations of why these classes work as they do, with informative examples. Several new chapters and major sections have been added, and every chapter has been updated to reflect today’s best practices for building robust, efficient, and maintainable Java software.

Key changes in this edition include

  • New chapters on generics, enums, and annotations, the most powerful new language features introduced in J2SE 5.0

  • Changes to classes and methods throughout to reflect the addition of generics

  • Major new sections on assertions and regular expressions

  • Coverage of all the new language features, from autoboxing and variable argument methods to the enhanced for-loop and covariant return types

  • Coverage of key new classes, such as Formatter and Scanner

  • The Java™ Programming Language, Fourth Edition, is the definitive tutorial introduction to the Java language and essential libraries and an indispensable reference for all programmers, including those with extensive experience. It brings together insights you can only get from the creators of Java: insights that will help you write software of exceptional quality.

    Table of Contents

    1. Copyright
      1. Dedication
    2. The Java™ Series
    3. Preface
      1. About This Book
      2. Examples and Documentation
      3. Acknowledgments (Fourth Edition)
      4. Acknowledgments (Third Edition)
      5. Acknowledgments (Second Edition)
      6. Acknowledgments (First Edition)
    4. 1. A Quick Tour
      1. 1.1. Getting Started
      2. 1.2. Variables
      3. 1.3. Comments in Code
      4. 1.4. Named Constants
      5. 1.5. Unicode Characters
      6. 1.6. Flow of Control
      7. 1.7. Classes and Objects
        1. 1.7.1. Creating Objects
        2. 1.7.2. Static or Class Fields
        3. 1.7.3. The Garbage Collector
      8. 1.8. Methods and Parameters
        1. 1.8.1. Invoking a Method
        2. 1.8.2. The this Reference
        3. 1.8.3. Static or Class Methods
      9. 1.9. Arrays
      10. 1.10. String Objects
        1. 1.10.1. String Conversion and Formatting
      11. 1.11. Extending a Class
        1. 1.11.1. Invoking Methods of the Superclass
        2. 1.11.2. The Object Class
        3. 1.11.3. Type Casting
      12. 1.12. Interfaces
      13. 1.13. Generic Types
      14. 1.14. Exceptions
      15. 1.15. Annotations
      16. 1.16. Packages
      17. 1.17. The Java Platform
      18. 1.18. Other Topics Briefly Noted
    5. 2. Classes and Objects
      1. 2.1. A Simple Class
        1. 2.1.1. Class Members
        2. 2.1.2. Class Modifiers
      2. 2.2. Fields
        1. 2.2.1. Field Initialization
        2. 2.2.2. Static Fields
        3. 2.2.3. final Fields
      3. 2.3. Access Control
      4. 2.4. Creating Objects
      5. 2.5. Construction and Initialization
        1. 2.5.1. Constructors
        2. 2.5.2. Initialization Blocks
        3. 2.5.3. Static Initialization
      6. 2.6. Methods
        1. 2.6.1. Static Methods
        2. 2.6.2. Method Invocations
        3. 2.6.3. Methods with Variable Numbers of Arguments
        4. 2.6.4. Method Execution and Return
        5. 2.6.5. Parameter Values
        6. 2.6.6. Using Methods to Control Access
      7. 2.7. this
      8. 2.8. Overloading Methods
      9. 2.9. Importing Static Member Names
      10. 2.10. The main Method
      11. 2.11. Native Methods
    6. 3. Extending Classes
      1. 3.1. An Extended Class
      2. 3.2. Constructors in Extended Classes
        1. 3.2.1. Constructor Order Dependencies
      3. 3.3. Inheriting and Redefining Members
        1. 3.3.1. Overriding
        2. 3.3.2. Hiding Fields
        3. 3.3.3. Accessing Inherited Members
        4. 3.3.4. Accessibility and Overriding
        5. 3.3.5. Hiding Static Members
        6. 3.3.6. The super Keyword
      4. 3.4. Type Compatibility and Conversion
        1. 3.4.1. Compatibility
        2. 3.4.2. Explicit Type Casting
        3. 3.4.3. Testing for Type
      5. 3.5. What protected Really Means
      6. 3.6. Marking Methods and Classes final
      7. 3.7. Abstract Classes and Methods
      8. 3.8. The Object Class
      9. 3.9. Cloning Objects
        1. 3.9.1. Strategies for Cloning
        2. 3.9.2. Correct Cloning
        3. 3.9.3. Shallow versus Deep Cloning
      10. 3.10. Extending Classes: How and When
      11. 3.11. Designing a Class to Be Extended
        1. 3.11.1. Designing an Extensible Framework
      12. 3.12. Single Inheritance versus Multiple Inheritance
    7. 4. Interfaces
      1. 4.1. A Simple Interface Example
      2. 4.2. Interface Declarations
        1. 4.2.1. Interface Constants
        2. 4.2.2. Interface Methods
        3. 4.2.3. Interface Modifiers
      3. 4.3. Extending Interfaces
        1. 4.3.1. Inheriting and Hiding Constants
        2. 4.3.2. Inheriting, Overriding, and Overloading Methods
      4. 4.4. Working with Interfaces
        1. 4.4.1. Implementing Interfaces
        2. 4.4.2. Using an Implementation
      5. 4.5. Marker Interfaces
      6. 4.6. When to Use Interfaces
    8. 5. Nested Classes and Interfaces
      1. 5.1. Static Nested Types
        1. 5.1.1. Static Nested Classes
        2. 5.1.2. Nested Interfaces
      2. 5.2. Inner Classes
        1. 5.2.1. Accessing Enclosing Objects
        2. 5.2.2. Extending Inner Classes
        3. 5.2.3. Inheritance, Scoping, and Hiding
      3. 5.3. Local Inner Classes
        1. 5.3.1. Inner Classes in Static Contexts
      4. 5.4. Anonymous Inner Classes
      5. 5.5. Inheriting Nested Types
      6. 5.6. Nesting in Interfaces
        1. 5.6.1. Modifiable Variables in Interfaces
      7. 5.7. Implementation of Nested Types
    9. 6. Enumeration Types
      1. 6.1. A Simple Enum Example
      2. 6.2. Enum Declarations
        1. 6.2.1. Enum Modifiers
      3. 6.3. Enum Constant Declarations
        1. 6.3.1. Construction
        2. 6.3.2. Constant Specific Behavior
      4. 6.4. java.lang.Enum
      5. 6.5. To Enum or Not
    10. 7. Tokens, Values, and Variables
      1. 7.1. Lexical Elements
        1. 7.1.1. Character Set
        2. 7.1.2. Comments
        3. 7.1.3. Tokens
        4. 7.1.4. Identifiers
        5. 7.1.5. Keywords
      2. 7.2. Types and Literals
        1. 7.2.1. Reference Literals
        2. 7.2.2. Boolean Literals
        3. 7.2.3. Character Literals
        4. 7.2.4. Integer Literals
        5. 7.2.5. Floating-Point Literals
        6. 7.2.6. String Literals
        7. 7.2.7. Class Literals
      3. 7.3. Variables
        1. 7.3.1. Field and Local Variable Declarations
        2. 7.3.2. Parameter Variables
        3. 7.3.3. final Variables
      4. 7.4. Array Variables
        1. 7.4.1. Array Modifiers
        2. 7.4.2. Arrays of Arrays
        3. 7.4.3. Array Initialization
        4. 7.4.4. Arrays and Types
      5. 7.5. The Meanings of Names
    11. 8. Primitives as Types
      1. 8.1. Common Fields and Methods
        1. 8.1.1. Construction
        2. 8.1.2. Constants
        3. 8.1.3. Common Methods
      2. 8.2. Void
      3. 8.3. Boolean
      4. 8.4. Number
        1. 8.4.1. The Integer Wrappers
        2. 8.4.2. The Floating-Point Wrapper Classes
      5. 8.5. Character
        1. 8.5.1. Working with UTF-16
      6. 8.6. Boxing Conversions
    12. 9. Operators and Expressions
      1. 9.1. Arithmetic Operations
        1. 9.1.1. Integer Arithmetic
        2. 9.1.2. Floating-Point Arithmetic
        3. 9.1.3. Strict and Non-Strict Floating-Point Arithmetic
      2. 9.2. General Operators
        1. 9.2.1. Increment and Decrement Operators
        2. 9.2.2. Relational and Equality Operators
        3. 9.2.3. Logical Operators
        4. 9.2.4. instanceof
        5. 9.2.5. Bit Manipulation Operators
        6. 9.2.6. The Conditional Operator ?:
        7. 9.2.7. Assignment Operators
        8. 9.2.8. String Concatenation Operator
        9. 9.2.9. new
      3. 9.3. Expressions
        1. 9.3.1. Order of Evaluation
        2. 9.3.2. Expression Type
      4. 9.4. Type Conversions
        1. 9.4.1. Implicit Type Conversions
        2. 9.4.2. Explicit Type Casts
        3. 9.4.3. String Conversions
      5. 9.5. Operator Precedence and Associativity
      6. 9.6. Member Access
        1. 9.6.1. Finding the Right Method
    13. 10. Control Flow
      1. 10.1. Statements and Blocks
      2. 10.2. if–else
      3. 10.3. switch
      4. 10.4. while and do–while
      5. 10.5. for
        1. 10.5.1. Basic for Statement
        2. 10.5.2. Enhanced for Statement
      6. 10.6. Labels
      7. 10.7. break
      8. 10.8. continue
      9. 10.9. return
      10. 10.10. What, No goto?
    14. 11. Generic Types
      1. 11.1. Generic Type Declarations
        1. 11.1.1. Bounded Type Parameters
        2. 11.1.2. Nested Generic Types
      2. 11.2. Working with Generic Types
        1. 11.2.1. Subtyping and Wildcards
      3. 11.3. Generic Methods and Constructors
        1. 11.3.1. Generic Invocations and Type Inference
      4. 11.4. Wildcard Capture
      5. 11.5. Under the Hood: Erasure and Raw Types
        1. 11.5.1. Erasure at Runtime
        2. 11.5.2. Overloading and Overriding
      6. 11.6. Finding the Right Method — Revisited
      7. 11.7. Class Extension and Generic Types
    15. 12. Exceptions and Assertions
      1. 12.1. Creating Exception Types
      2. 12.2. throw
        1. 12.2.1. Transfer of Control
        2. 12.2.2. Asynchronous Exceptions
      3. 12.3. The throws Clause
        1. 12.3.1. throws Clauses and Method Overriding
        2. 12.3.2. throws Clauses and Native Methods
      4. 12.4. try, catch, and finally
        1. 12.4.1. finally
      5. 12.5. Exception Chaining
      6. 12.6. Stack Traces
      7. 12.7. When to Use Exceptions
      8. 12.8. Assertions
        1. 12.8.1. The assert Statement
      9. 12.9. When to Use Assertions
        1. 12.9.1. State Assertions
        2. 12.9.2. Control Flow Assertions
      10. 12.10. Turning Assertions On and Off
        1. 12.10.1. Why Turn Assertions On and Off?
        2. 12.10.2. Controlling Assertions on the Command Line
        3. 12.10.3. Complete Removal
        4. 12.10.4. Making Assertions Required
    16. 13. Strings and Regular Expressions
      1. 13.1. Character Sequences
      2. 13.2. The String Class
        1. 13.2.1. Basic String Operations
        2. 13.2.2. String Comparisons
        3. 13.2.3. String Literals, Equivalence and Interning
        4. 13.2.4. Making Related Strings
        5. 13.2.5. String Conversions
        6. 13.2.6. Strings and char Arrays
        7. 13.2.7. Strings and byte Arrays
        8. 13.2.8. Character Set Encoding
      3. 13.3. Regular Expression Matching
        1. 13.3.1. Regular Expressions
        2. 13.3.2. Compiling and Matching with Regular Expressions
        3. 13.3.3. Replacing
        4. 13.3.4. Regions
        5. 13.3.5. Efficiency
      4. 13.4. The StringBuilder Class
        1. 13.4.1. Modifying the Buffer
        2. 13.4.2. Getting Data Out
        3. 13.4.3. Capacity Management
        4. 13.4.4. The StringBuffer Class
      5. 13.5. Working with UTF-16
    17. 14. Threads
      1. 14.1. Creating Threads
      2. 14.2. Using Runnable
      3. 14.3. Synchronization
        1. 14.3.1. synchronized Methods
        2. 14.3.2. Static synchronized Methods
        3. 14.3.3. synchronized Statements
        4. 14.3.4. Synchronization Designs
      4. 14.4. wait, notifyAll, and notify
      5. 14.5. Details of Waiting and Notification
      6. 14.6. Thread Scheduling
        1. 14.6.1. Voluntary Rescheduling
      7. 14.7. Deadlocks
      8. 14.8. Ending Thread Execution
        1. 14.8.1. Cancelling a Thread
        2. 14.8.2. Waiting for a Thread to Complete
      9. 14.9. Ending Application Execution
      10. 14.10. The Memory Model: Synchronization and volatile
        1. 14.10.1. Synchronization Actions
        2. 14.10.2. Final Fields and Security
        3. 14.10.3. The Happens-Before Relationship
      11. 14.11. Thread Management, Security, and ThreadGroup
      12. 14.12. Threads and Exceptions
        1. 14.12.1. Don't stop
        2. 14.12.2. Stack Traces
      13. 14.13. ThreadLocal Variables
      14. 14.14. Debugging Threads
    18. 15. Annotations
      1. 15.1. A Simple Annotation Example
      2. 15.2. Annotation Types
      3. 15.3. Annotating Elements
      4. 15.4. Restricting Annotation Applicability
      5. 15.5. Retention Policies
      6. 15.6. Working with Annotations
    19. 16. Reflection
      1. 16.1. The Class Class
        1. 15.7.1. Type Tokens
        2. 16.1.2. Class Inspection
        3. 16.1.3. Examining Class Members
        4. 16.1.4. Naming Classes
        5. 16.1.5. Obtaining Class Objects by Name
        6. 16.1.6. Runtime Type Queries
      2. 16.2. Annotation Queries
      3. 16.3. The Modifier Class
      4. 16.4. The Member classes
      5. 16.5. Access Checking and AccessibleObject
      6. 16.6. The Field Class
        1. 16.6.1. Final Fields
      7. 16.7. The Method Class
      8. 16.8. Creating New Objects and the Constructor Class
        1. 16.8.1. Inner Class Constructors
      9. 16.9. Generic Type Inspection
        1. 16.9.1. Type Variables
        2. 16.9.2. Parameterized Types
        3. 16.9.3. Wildcards
        4. 16.9.4. Generic Arrays
        5. 16.9.5. String Representations of Type Objects
      10. 16.10. Arrays
        1. 16.10.1. Genericity and Dynamic Arrays
      11. 16.11. Packages
      12. 16.12. The Proxy Class
      13. 16.13. Loading Classes
        1. 16.13.1. The ClassLoader Class
        2. 16.13.2. Preparing a Class for Use
        3. 16.13.3. Loading Related Resources
      14. 16.14. Controlling Assertions at Runtime
    20. 17. Garbage Collection and Memory
      1. 17.1. Garbage Collection
      2. 17.2. A Simple Model
      3. 17.3. Finalization
        1. 17.3.1. Resurrecting Objects during finalize
      4. 17.4. Interacting with the Garbage Collector
      5. 17.5. Reachability States and Reference Objects
        1. 17.5.1. The Reference Class
        2. 17.5.2. Strengths of Reference and Reachability
        3. 17.5.3. Reference Queues
        4. 17.5.4. Finalization and Reachability
    21. 18. Packages
      1. 18.1. Package Naming
      2. 18.2. Type Imports
      3. 18.3. Package Access
        1. 18.3.1. Accessibility and Overriding Methods
      4. 18.4. Package Contents
      5. 18.5. Package Annotations
      6. 18.6. Package Objects and Specifications
    22. 19. Documentation Comments
      1. 19.1. The Anatomy of a Doc Comment
      2. 19.2. Tags
        1. 19.2.1. @see
        2. 19.2.2. {@link} and {@linkplain}
        3. 19.2.3. @param
        4. 19.2.4. @return
        5. 19.2.5. @throws and @exception
        6. 19.2.6. @deprecated
        7. 19.2.7. @author
        8. 19.2.8. @version
        9. 19.2.9. @since
        10. 19.2.10. {@literal} and {@code}
        11. 19.2.11. {@value}
        12. 19.2.12. {@docRoot}
        13. 19.2.13. {@inheritDoc}
      3. 19.3. Inheriting Method Documentation Comments
        1. 19.3.1. Inheriting @throws Comments
      4. 19.4. A Simple Example
      5. 19.5. External Conventions
        1. 19.5.1. Package and Overview Documentation
        2. 19.5.2. The doc-files Directory
      6. 19.6. Notes on Usage
    23. 20. The I/O Package
      1. 20.1. Streams Overview
      2. 20.2. Byte Streams
        1. 20.2.1. InputStream
        2. 20.2.2. OutputStream
      3. 20.3. Character Streams
        1. 20.3.1. Reader
        2. 20.3.2. Writer
        3. 20.3.3. Character Streams and the Standard Streams
      4. 20.4. InputStreamReader and OutputStreamWriter
      5. 20.5. A Quick Tour of the Stream Classes
        1. 20.5.1. Synchronization and Concurrency
        2. 20.5.2. Filter Streams
        3. 20.5.3. Buffered Streams
        4. 20.5.4. Piped Streams
        5. 20.5.5. ByteArray Byte Streams
        6. 20.5.6. CharArray Character Streams
        7. 20.5.7. String Character Streams
        8. 20.5.8. Print Streams
        9. 20.5.9. LineNumberReader
        10. 20.5.10. SequenceInputStream
        11. 20.5.11. Pushback Streams
        12. 20.5.12. StreamTokenizer
      6. 20.6. The Data Byte Streams
        1. 20.6.1. DataInput and DataOutput
        2. 20.6.2. The Data Stream Classes
      7. 20.7. Working with Files
        1. 20.7.1. File Streams and FileDescriptor
        2. 20.7.2. RandomAccessFile
        3. 20.7.3. The File Class
        4. 20.7.4. FilenameFilter and FileFilter
      8. 20.8. Object Serialization
        1. 20.8.1. The Object Byte Streams
        2. 20.8.2. Making Your Classes Serializable
        3. 20.8.3. Serialization and Deserialization Order
        4. 20.8.4. Customized Serialization
        5. 20.8.5. Object Versioning
        6. 20.8.6. Serialized Fields
        7. 20.8.7. The Externalizable Interface
        8. 20.8.8. Documentation Comment Tags
      9. 20.9. The IOException Classes
      10. 20.10. A Taste of New I/O
    24. 21. Collections
      1. 21.1. Collections
        1. 21.1.1. Exception Conventions
      2. 21.2. Iteration
      3. 21.3. Ordering with Comparable and Comparator
      4. 21.4. The Collection Interface
      5. 21.5. Set and SortedSet
        1. 21.5.1. HashSet
        2. 21.5.2. LinkedHashSet
        3. 21.5.3. TreeSet
      6. 21.6. List
        1. 21.6.1. ArrayList
        2. 21.6.2. LinkedList
        3. 21.6.3. RandomAccess Lists
      7. 21.7. Queue
        1. 21.7.1. PriorityQueue
      8. 21.8. Map and SortedMap
        1. 21.8.1. HashMap
        2. 21.8.2. LinkedHashMap
        3. 21.8.3. IdentityHashMap
        4. 21.8.4. WeakHashMap
        5. 21.8.5. TreeMap
      9. 21.9. enum Collections
        1. 21.9.1. EnumSet
        2. 21.9.2. EnumMap
      10. 21.10. Wrapped Collections and the Collections Class
        1. 21.10.1. The Collections Utilities
        2. 21.10.2. The Unmodifiable Wrappers
        3. 21.10.3. The Checked Wrappers
      11. 21.11. Synchronized Wrappers and Concurrent Collections
        1. 21.11.1. The Synchronized Wrappers
        2. 21.11.2. The Concurrent Collections
      12. 21.12. The Arrays Utility Class
      13. 21.13. Writing Iterator Implementations
      14. 21.14. Writing Collection Implementations
      15. 21.15. The Legacy Collection Types
        1. 21.15.1. Enumeration
        2. 21.15.2. Vector
        3. 21.15.3. Stack
        4. 21.15.4. Dictionary
        5. 21.15.5. Hashtable
      16. 21.16. Properties
    25. 22. Miscellaneous Utilities
      1. 22.1. Formatter
        1. 22.1.1. Format Specifiers
        2. 22.1.2. Integer Conversions
        3. 22.1.3. Floating-Point Conversions
        4. 22.1.4. Character Conversions
        5. 22.1.5. General Conversions
        6. 22.1.6. Custom Formatting
        7. 22.1.7. Format Exceptions
        8. 22.1.8. The Formatter Class
      2. 22.2. BitSet
      3. 22.3. Observer/Observable
      4. 22.4. Random
      5. 22.5. Scanner
        1. 22.5.1. Stream of Values
        2. 22.5.2. Scanning Lines
        3. 22.5.3. Using Scanner
        4. 22.5.4. Localization
      6. 22.6. StringTokenizer
      7. 22.7. Timer and TimerTask
      8. 22.8. UUID
      9. 22.9. Math and StrictMath
    26. 23. System Programming
      1. 23.1. The System Class
        1. 23.1.1. Standard I/O Streams
        2. 23.1.2. System Properties
        3. 23.1.3. Utility Methods
      2. 23.2. Creating Processes
        1. 23.2.1. Process
        2. 23.2.2. Process Environments
        3. 23.2.3. ProcessBuilder
        4. 23.2.4. Portability
      3. 23.3. Shutdown
        1. 23.3.1. Shutdown Hooks
        2. 23.3.2. The Shutdown Sequence
        3. 23.3.3. Shutdown Strategies
      4. 23.4. The Rest of Runtime
        1. 23.4.1. Loading Native Code
        2. 23.4.2. Debugging
      5. 23.5. Security
        1. 23.5.1. The SecurityManager Class
        2. 23.5.2. Permissions
        3. 23.5.3. Security Policies
        4. 23.5.4. Access Controllers and Privileged Execution
    27. 24. Internationalization and Localization
      1. 24.1. Locale
      2. 24.2. Resource Bundles
        1. 24.2.1. ListResourceBundle
        2. 24.2.2. PropertyResourceBundle
        3. 24.2.3. Subclassing ResourceBundle
      3. 24.3. Currency
      4. 24.4. Time, Dates, and Calendars
        1. 24.4.1. Calendars
        2. 24.4.2. Time Zones
        3. 24.4.3. GregorianCalendar and SimpleTimeZone
      5. 24.5. Formatting and Parsing Dates and Times
        1. 24.5.1. Using Formatter with Dates and Times
      6. 24.6. Internationalization and Localization for Text
        1. 24.6.1. Collation
        2. 24.6.2. Formatting and Parsing
        3. 24.6.3. Text Boundaries
    28. 25. Standard Packages
      1. 25.1. java.awt — The Abstract Window Toolkit
      2. 25.2. java.applet — Applets
      3. 25.3. java.beans — Components
      4. 25.4. java.math — Mathematics
      5. 25.5. java.net — The Network
      6. 25.6. java.rmi — Remote Method Invocation
      7. 25.7. java.security and Related Packages — Security Tools
      8. 25.8. java.sql — Relational Database Access
      9. 25.9. Utility Subpackages
        1. 25.9.1. Concurrency Utilities — java.util.concurrent
        2. 25.9.2. Archive Files — java.util.jar
        3. 25.9.3. ZIP Files — java.util.zip
      10. 25.10. javax.* — Standard Extensions
      11. 25.11. javax.accessibility — Accessibility for GUIs
      12. 25.12. javax.naming — Directory and Naming Services
      13. 25.13. javax.sound — Sound Manipulation
      14. 25.14. javax.swing — Swing GUI Components
      15. 25.15. org.omg.CORBA — CORBA APIs
    29. A. Application Evolution
      1. A.1. Language, Library, and Virtual Machine Versions
      2. A.2. Dealing with Multiple Dialects
      3. A.3. Generics: Reification, Erasure, and Raw Types
        1. A.3.1. Raw Types, “Unchecked” Warnings, and Bridge Methods
        2. A.3.2. API Issues
    30. B. Useful Tables
    31. Further Reading
      1. Java Platform Topics
      2. Object-Oriented Design
      3. Multithreaded Programming
      4. Generics
      5. Regular Expressions
      6. General Programming Techniques
      7. Related Languages
      8. Software Engineering
      9. Visual Design & GUI Design
    32. Colophon
      1. Note to Translators
    33. Article
    34. Exercises
    35. Quotes