You are previewing Core Java™ 1.1 Volume II - Advanced Features.
O'Reilly logo
Core Java™ 1.1 Volume II - Advanced Features

Book Description


76696-4

“Core Java is the best choice for experienced programmers. It is unmatched for technical depth, yet remains highly readable.” —K.N. King, Computer Reviews

Comprehensive and up-to-date coverage of advanced topics including:

  • input and output

  • object serialization

  • multithreading

  • network programming

  • distributed objects

  • databases

  • native methods

  • Java Beans

  • Put Java to work on real problems!

    Written for serious programmers who have mastered the fundamentals of the Java language, Core Java 1.1, Vol. II thoroughly explains the more advanced features and libraries you need to build real programs.

    New chapters on Java Beans, Advanced AWT, Security, and Internationalization focus on the features and functions added to Java with the release of JDK 1.1. Updated chapters on multithreading and networking include extensive examples and thoroughly tested sample code that illustrate some of the most powerful features of Java.

    Volume II also provides in depth coverage of the Java Enterprise API-JDBC, RMI, Native Methods-that demonstrates what objects everywhere can be realistically used for.

    The CD-ROM includes all Java source code examples from the book, the latest version of JDK 1.1.x and useful shareware as well as all of the example code from Core Java 1.1, Volume I.

    Table of Contents

    1. Copyright
    2. Tables, Examples, and Figures
      1. Tables
      2. Examples
      3. Figures
    3. Preface
      1. To the Reader
      2. About This Book
      3. Conventions
    4. Acknowledgements
    5. 1. Input and Output
      1. Streams
        1. Reading and Writing Bytes
      2. The Complete Stream Zoo
        1. Mixing and Matching Stream Filters
        2. Data Streams
        3. Random-Access File Streams
          1. Text streams
          2. Writing text output
          3. Reading text input
      3. ZIP File Streams
      4. Putting Streams to Use
        1. Writing Delimited Output
        2. String Tokenizers and Delimited Text
        3. Reading Delimited Input
        4. Random-Access Streams
      5. Object Streams
        1. Storing Objects of Variable Type
        2. The Object Serialization File Format
        3. The Problem of Saving Object References
        4. The Output Format for Object References
        5. Security
        6. Versioning
      6. File Management
    6. 2. Multithreading
      1. What Are Threads?
        1. Using Threads to Give Other Tasks a Chance
        2. Running and Starting Threads
        3. Running Multiple Threads
      2. Thread Properties
        1. Thread States
          1. New threads
          2. Runnable threads
          3. Blocked threads
        2. Moving Out of a Blocked State
        3. Dead Threads
        4. Finding Out the State of a Thread
      3. Thread Priorities
      4. Cooperating and Selfish Threads
        1. Thread Groups
      5. Synchronization
        1. Thread Communication Without Synchronization
        2. Synchronizing Access to Shared Resources
        3. Deadlocks
      6. Using Pipes for Communication between Threads
      7. Timers
        1. Daemon Threads
      8. Animation
        1. The Runnable Interface
        2. Loading and Displaying Frames
        3. Using a Thread to Control the Animation
    7. 3. Networking
      1. Connecting to a Server
      2. Implementing Servers
        1. Serving Multiple Clients
      3. Retrieving Information from a Remote Site
      4. Sending Information to the Server
        1. CGI Scripts
        2. Completing the MailOrder Applet
      5. Harvesting Information from the Web
        1. Connecting to a Gopher Site
        2. Applet Security
        3. Proxy Servers
    8. 4. Database Connectivity: JDBC
      1. The Design of JDBC
      2. Typical Uses of the JDBC
      3. Structured Query Language
      4. Installing JDBC
      5. Basic JDBC Programming Concepts
        1. Database URLs
        2. Making the Connection
        3. Querying with JDBC
      6. Populating a Database
      7. Executing Queries
      8. Metadata
    9. 5. Remote Objects
      1. Introduction to Remote Objects: The Roles of Client and Server
      2. Remote Method Invocations
        1. Stubs and Skeletons
        2. Dynamic Class Loading
      3. Setting Up Remote Method Invocation
        1. Interfaces and Implementations
        2. Creating Server Objects
        3. The Client Side
        4. Summary of Steps for Setting up RMI
      4. Parameter Passing in Remote Methods
        1. Passing Nonremote Objects
        2. Passing Remote Objects
        3. Using Remote Objects in Hash Tables
        4. Cloning Remote Objects
        5. Inappropriate Remote Parameters
      5. Using RMI with Applets
    10. 6. Advanced AWT
      1. An Overview of Java's Image Manipulation
      2. The Java Color Models
      3. Image Filters
        1. CropImageFilter
        2. RGBImageFilter
      4. Memory Image Sources
        1. A Formula-based Example: A Black-and-White Mandelbrot Set
        2. Memory Source Animations
      5. Pixel Grabbing
      6. Data Transfer
        1. Classes and Interfaces for Data Transfer
        2. Transferring Text
        3. Building a Transferable
          1. The Transferable Interface and Data Flavors
          2. Building an Image Transferable
        4. Using the ImageSelection Class
        5. Transferring Java Objects via the System Clipboard
    11. 7. Java Beans
      1. Why Beans?
      2. The Bean-Writing Process
      3. The BDK and the BeanBox
        1. Using the BeanBox
          1. Using a Bean in the BeanBox
          2. Building a Simple Application in the BeanBox
          3. Saving and Restoring the State of the BeanBox
          4. Building an Applet from the BeanBox
          5. Adding Beans to the Toolbox
      4. Building an Image Viewer Application via Beans
      5. “Design Patterns” for Bean Properties and Events
      6. Writing Bean Properties
        1. Simple Properties
        2. Indexed Properties
        3. Bound Properties
        4. Constrained Properties
      7. Adding Custom Bean Events
      8. Property Editors
        1. Writing a Property Editor
          1. Simple Property Editors
          2. GUI-Based Property Editors
          3. Summing Up
      9. Going Beyond “Design Patterns”—Building a BeanInfo Class
        1. FeatureDescriptor Objects
      10. Customizers
        1. Writing a Customizer Class
      11. Advanced Use of Introspection
    12. 8. Security
      1. Class Loaders
        1. Writing Your Own Class Loader
        2. Verifying Your New Class
      2. Security Managers
        1. An Example of a Custom Security Manager
      3. The Java Security Package
        1. Message Digests
        2. Digital Signatures
      4. Authentication
      5. The Java Authentication Framework
        1. The X.509 Certficate Format
        2. Generating Certificates
      6. Code Signing
        1. Signing JAR Files
        2. Browsing Signed Applets
        3. Trusted Applets
        4. The Future of Applet Signing
      7. Encryption
        1. Ciphers
        2. Padding
        3. Providers
        4. Cipher Streams
    13. 9. Internationalization
      1. Locales
      2. Numbers and Currencies
      3. Date and Time
      4. Text
        1. Collation (Ordering)
        2. Text Boundaries
        3. Message Formatting
        4. Choice Formats
        5. Character Set Conversion
        6. International Issues and Source Files
      5. Resource Bundles
        1. Locating Resources
        2. Placing Resources into Bundles
      6. Graphical User Interface Localization
        1. Localizing an Applet
    14. 10. Native Methods
      1. Calling a C Function from Java
        1. Working with the printf Function
      2. Numeric Parameters and Return Values
        1. Using printf for Formatting Numbers
      3. String Parameters
        1. A Java Equivalent of sprintf
      4. Accessing Object Fields
      5. Accessing Static Fields
      6. Signatures
      7. Calling Java Methods
        1. Nonstatic Methods
        2. Static Methods
        3. Constructors
        4. Alternative Method Invocations
      8. Arrays
      9. Error-Handling
      10. The Invocation API
      11. A Complete Example: Accessing the Windows Registry
        1. An Overview of the Windows Registry
        2. A Java Interface for Accessing the Registry
        3. Implementing the Registry Access Functions as Native Methods
    15. I. Installing the CD-ROM
      1. Contents of the CD-ROM
      2. Installation Directions
        1. Install the JDK
        2. Install Shareware Software
        3. Install the Core Java Example Files
      3. Testing the Installation
        1. Testing the JDK
        2. Testing the Core Java Utility Package
      4. Troubleshooting
        1. PATH and CLASSPATH
        2. Memory Problems
        3. Case Sensitivity
        4. Older Browsers
        5. About Other Platforms
        6. Updates and Bug Fixes
      5. Binary Code License