Table of Contents

• Getting Started
• Learning the Java Language
• Writing Applets
• Essential Java Classes
• Creating a User Interface
• Custom Networking
• To 1.1 -- And Beyond!
• Putting It All Together
• Writing Global Programs
• Using the JNI to Integrate Native Code and Java Programs
• JavaBeans Tutorial
• Java Security 1.1

• Getting Started
  • The Java Phenomenon
    • What Is Java?
    • What Can Java Do?
    • How Will Java Change My Life?
  • The "Hello World" Applet
    • The Anatomy of a Java Applet
      • Importing Classes and Packages
      • Defining an Applet Subclass
      • Implementing Applet Methods
      • Running an Applet
  • The "Hello World" Application
    • The Anatomy of a Java Application
      • Comments in Java Code
      • Defining a Class
      • The main() Method
      • Using Classes and Objects
  • Common Compiler and Interpreter Problems (and Their Solutions)
• Learning the Java Language
  • Object-Oriented Programming Concepts
    • What Is an Object?
    • What Are Messages?
    • What Are Classes?
    • What Is Inheritance?
    • Where Can I Get More Information?
  • The Nuts and Bolts of the Java Language
    • Running the countChars Method
    • Variables and Data Types
    • Operators
    • Expressions
    • Control Flow Statements
    • Arrays and Strings
  • Objects and Classes in Java
    • A Brief Introduction to Classes
    • The Life Cycle of an Object
      • Creating Objects
      • Using Objects
      • Cleaning Up Unused Objects
    • Creating Classes
      • The Class Declaration
      • The Class Body
      • Providing Constructors for Your Classes
      • Declaring Member Variables
      • Implementing Methods
        • Details of a Method Declaration
        • Passing Information into a Method
        • The Method Body
      • Controlling Access to Members of a Class
      • Understanding Instance and Class Members
      • Writing a finalize Method
    • Reality Break! The Spot Applet
      • Extending a Class
      • Implementing an Interface
      • Using an Inner Class to Implement an Adapter
    • Summary
  • More Features of the Java Language
    • Managing Inheritance
      • Understanding Inheritance
        • Overriding Methods
      • Being a Descendent of Object
      • Writing Final Classes and Methods
      • Writing Abstract Classes and Methods
    • Creating Interfaces
      • What Is an Interface?
      • Defining an Interface
      • Implementing the Sleeper Interface
      • Using an Interface as a Type
      • Warning! Interfaces Cannot Grow
    • Implementing Nested Classes
      • Inner Classes
    • Creating and Using Packages
      • Creating a Package
      • Using Package Members
      • Managing Source and Class Files
• Writing Applets
  • Overview of Applets
    • The Life Cycle of an Applet
    • Methods for Milestones
    • Methods for Drawing and Event Handling
    • Methods for Adding UI Components
    • What Applets Can and Cannot Do
    • Test Driving an Applet
    • Summary
  • Taking Advantage of the Applet API
    • Finding and Loading Data Files
    • Displaying Short Status Strings
    • Displaying Documents in the Browser
    • Sending Messages to Other Applets
    • Playing Sounds
    • Defining and Using Applet Parameters
      • Deciding Which Parameters to Support
      • Writing the Code to Support Parameters
      • Giving Information About Parameters
    • Using the <APPLET> Tag
  • Practical Considerations when Writing Applets
    • Security Restrictions
    • Creating a User Interface
      • Using the AWT to Create a GUI
      • Displaying Diagnostics to the Standard Output and Standard Error Streams
    • Getting System Properties
    • Threads in Applets
    • Working with a Server-Side Application
      • A Simple Network Client Applet
      • Using a Server to Work Around Security Restrictions
  • Finishing an Applet
    • Before You Ship that Applet
    • The Perfectly Finished Applet
  • Common Problems (and Their Solutions)
• Essential Java Classes
  • The String and StringBuffer Classes
    • Why Two String Classes?
    • Creating Strings and StringBuffers
    • Accessor Methods
      • More Accessor Methods
    • Modifying StringBuffers
    • Converting Objects to Strings
    • Converting Strings to Numbers
    • Strings and the Java Compiler
    • Java Strings are First-Class Objects
  • Setting Program Attributes
    • Using Properties to Manage Program Attributes
    • Command-Line Arguments
  • Accessing System Resources
    • Using the System Class
    • The Standard I/O Streams
    • System Properties
    • Forcing Finalization and Garbage Collection
    • Providing Your Own Security Manager
      • Introducing the Security Manager
      • Writing a Security Manager
      • Installing Your Security Manager
      • Deciding What SecurityManager Methods to Override
    • Miscellaneous System Methods
    • The Runtime Object
  • Handling Errors Using Exceptions
    • What's an Exception and Why Do I Care?
    • Your First Encounter with Java Exceptions
    • Java's Catch or Specify Requirement
    • Dealing with Exceptions
      • The ListOfNumbers Example
      • Catching and Handling Exceptions
        • The try Block
        • The catch Block(s)
        • The finally Block
        • Putting It All Together
      • Specifying the Exceptions Thrown by a Method
    • How to Throw Exceptions
      • The throw Statement
      • The Throwable Class and Its Subclasses
      • Creating Your Own Exception Classes
    • Runtime Exceptions--The Controversy
  • Doing Two or More Tasks At Once: Threads
    • What Is a Thread?
    • Customizing a Thread's run Method
      • Subclassing Thread and Overriding run
      • Implementing the Runnable Interface
    • The Life Cycle of a Thread
    • Understanding Thread Priority
    • Synchronizing Threads
      • The Producer/Consumer Example
      • Locking an Object
        • Reaquiring a Lock
      • Using the notifyAll and wait Methods
      • Avoiding Starvation and Deadlock
    • Grouping Threads
      • The ThreadGroup Class
    • Summary
  • Reading and Writing
    • Overview of I/O Streams
    • Using the Data Sink Streams
      • How to Use File Streams
      • How to Use Pipe Streams
    • Using the Processing Streams
      • How to Concatenate Files
      • Working with Filtered Streams
        • How to Use DataInputStream and DataOutputStream
        • Writing Your Own Filtered Streams
    • Object Serialization
      • Serializing Objects
      • Providing Object Serialization foor Your Classes
    • Working with Random Access Files
      • Using Random Access Files
      • Writing Filters for Random Access Files
    • And the Rest
• Creating a User Interface
  • Overview of the Java UI
    • AWT Components
    • Other AWT Classes
    • The Anatomy of a GUI-Based Program
      • Classes in the Example Program
      • The Component Hierarchy
      • Drawing
      • Event Handling
  • Using Components, the GUI Building Blocks
    • Using the AWT Components
      • General Rules for Using Components
      • How to Use Buttons
      • How to Use Canvases
      • How to Use Checkboxes
      • How to Use Choices
      • How to Use Dialogs
      • How to Use Frames
      • How to Use Labels
      • How to Use Lists
      • How to Use Menus
      • How to Use Panels
      • How to Use Scrollbars
      • How to Use Scroll Panes
      • How to Use TextAreas and TextFields
    • The New AWT Event Model
      • Introduction to the New AWT Event Model
      • Using Adapters and Inner Classes to Handle AWT Events
      • Handling Standard AWT Events
      • Events Generated by AWT Components
      • Writing an Action Listener
      • Writing an Adjustment Listener
      • Writing a Component Listener
      • Writing a Container Listener
      • Writing a Focus Listener
      • Writing an Item Listener
      • Writing a Key Listener
      • Writing a Mouse Listener
      • Writing a Mouse-Motion Listener
      • Writing a Text Listener
      • Writing a Window Listener
    • Details of the Component Architecture
    • Common Component Problems (and Their Solutions)
  • Laying Out Components within a Container
    • Using Layout Managers
      • General Rules for Using Layout Managers
      • How to Use BorderLayout
      • How to Use CardLayout
      • How to Use FlowLayout
      • How to Use GridLayout
      • How to Use GridBagLayout
        • Specifying Constraints
        • The Applet Example Explained
    • Creating a Custom Layout Manager
    • Doing Without a Layout Manager (Absolute Positioning)
    • Common Layout Problems (and Their Solutions)
  • Working with Graphics
    • Overview of AWT Graphics Support
    • Using Graphics Primitives
      • Drawing Simple Shapes
      • Working with Text
    • Using Images
      • Loading Images
      • Displaying Images
      • Manipulating Images
        • How to Use an Image Filter
        • How to Write an Image Filter
    • Performing Animation
      • Creating the Animation Loop
      • Animating Graphics
      • Eliminating Flashing
        • Overriding the update() Method
        • Double Buffering
      • Moving an Image Across the Screen
      • Displaying a Sequence of Images
      • Improving the Appearance and Performance of Image Animation
    • Common Graphics Problems (and Their Solutions)
• Custom Networking
  • Overview of Networking
    • What You May Already Know About Networking in Java
    • Networking Basics
  • Working with URLs
    • What Is a URL?
    • Creating a URL
    • Parsing a URL
    • Reading Directly from a URL
    • Connecting to a URL
    • Reading from and Writing to a URLConnection
  • All About Sockets
    • What Is a Socket?
    • Reading from and Writing to a Socket
    • Writing the Server Side of a Socket
  • All About Datagrams
    • What Is a Datagram?
    • Writing a Datagram Client and Server
    • Broadcasting to Multiple Recipients
• To 1.1 -- And Beyond!
  • What's New in 1.1?
    • Internationalization
    • Security and Signed Applets
    • AWT Enhancements
    • JavaBeans Architecture
    • JAR File Format
    • Networking Enhancements
    • I/O Enhancements
    • Math Package
    • Remote Method Invocation
    • Reflection
    • Java Database Connectivity
    • Inner Classes
    • Java Native Interface
    • Performance Enhancements
    • Miscellaneous
  • Migrating to 1.1
    • When Should the Great Migration Occur?
    • What Does Deprecation Mean?
    • How to Convert Your Program
      • Special Coding Techniques
      • How to Convert Code that Uses I/O
      • How to Convert Code that Uses the AWT
    • Lists and Tables
      • Alternatives to Deprecated Methods in java.lang, java.net, and java.util
      • Character Streams versus Byte Streams
      • Alternatives to Deprecated Classes and Methods in java.io
      • Alternatives to Deprecated Methods in the AWT
      • All Deprecated Classes and Methods in JDK 1.1
      • Event-Conversion Table
      • Packages New for 1.1
      • Classes New for 1.1
      • Changes to the Java Language
    • JDK 1.1 Compability
      • Incompatible Changes in the 1.1 AWT API
  • A Preview of Things to Come
    • Security Enhancements
    • Java Foundation Classes (JFC)
    • Collections
    • Java Standard Extensions Architecture
    • JavaBeans Enhancements
    • Input Method Framework
    • Package Version Identification
    • RMI Enhancements
    • Serialization Enhancements
    • Weak References
    • Audio Enhancements
    • Java IDL
    • Performance Enhancements
    • JAR Enhancements
    • JNI Enhancements
    • Reflection Enhancements
    • Threads Changes
• Putting It All Together
  • Traditional BINGO
  • A Brief Description of the BINGO Programs
  • Let's Play!
  • The Code
    • The Primary Classes
    • Descriptions of Every Class
      • The Classes in bingo.game
      • The Classes in bingo.player
      • The Classes in bingo.shared
  • What's Interesting?
    • Design Decisions
    • Using the JFC to Implement the UI's
    • Synchronizing and Coordinating Threads
      • Using Synchronized Code Segments
      • Synchronizing Threads in the Player
      • Coordinating Threads in the Game
    • Communication Between the Game and the Player
      • Broadcasting Game Information
      • Handling Player Requests
    • Signing and Verifying the BINGO Cards
    • Writing a Custom EventQueue and Custom Events
    • Managing Program Settings in the Player
    • Other Interesting Tidbits
  • Exercises for the Reader
• Writing Global Programs
  • Internationalization? Localization? Arg!
    • What is a Global Program?
    • Common Problems with Global Programs
    • The Global Features of the JDK
  • Managing Data in Global Programs
    • Exploring AroundTheWorld
    • What Are Locales and How Do I Use Them?
    • Managing Locale-Sensitive Data
      • Loading Resource Bundles
      • Storing and Accessing Strings in Resource Bundles
      • Storing and Accessing Other Kinds of Objects in Resource Bundles
    • Representing Dates and Times
    • How to Format Numbers, Dates and Times, and Messages
      • The Format Classes
      • How to Format Numbers
      • How to Format Dates and Times
      • How to Format Messages
  • Internationalizing an Existing Program: Step by Step
    • Step 1: Identify the Locale-Sensitive Areas
    • Step 2: Isolate the Locale-Sensitive Data
    • Step 3: PENDING
  • Collation and Text Boundaries
    • The Collation Demo
      • Collation Details
    • The Text Boundary Demo
• Using the JNI to Integrate Native Code and Java Programs
  • Step By Step
    • Step 1: Write the Java Code
    • Step 2: Compile the Java Code
    • Step 3: Create the .h File
    • Step 4: Write the Native Method Implementation
    • Step 5: Create a Shared Library
    • Step 6: Run the Program
  • Implementing Native Methods
    • Declaring Native Methods
    • Java Types in Native Methods
    • Accessing Java Strings in Native Methods
    • Working With Java Arrays in Native Methods
    • Calling Java Methods
    • Accessing Java Fields
    • Handling Java Errors from Native Methods
    • Local and Global References
    • Threads and Native Methods
    • Invoking the Java Virtual Machine
    • JNI Programming in C++
• JavaBeans(tm) Tutorial
  • Introducing JavaBeans
    • JavaBeans Concepts
    • BDK Contents
    • BDK Example Beans
    • Future JavaBeans Features
  • BeanBox Basics
    • Starting and Using the BeanBox
    • Creating a Minimal Bean
    • The BeanBox Menus
  • Writing a Simple Bean
    • Implementing Properties
    • Manipulating Events in the BeanBox
    • Implementing Persistence
    • Using the BeanBox to Generate Applets
  • Writing Advanced Beans
    • Implementing Bound Properties
    • Implementing Constrained Properties
    • Implementing Indexed Properties
    • Customizing Beans
    • Using BeanInfo
    • Using the ActiveX Bridge
• Java Security 1.1
  • Java Security API Overview
  • Using the Security API to Generate and Verify a Signature
    • Step 1: Prepare Initial Program Structure
    • Step 2: Generate Public and Private Keys
    • Step 3: Sign the Data
    • Step 4: Verify the Signature
    • Step 5: Compile the Program
    • Step 6: Run the Program

Previous | Next | Up