Table of Contents

	Table of Contents
	Index

Special Edition Using Java 2 Standard Edition
By Brian  Keeton, Chuck  Cavaness, Geoff  Friesen
Publisher	: Que
Pub Date	: December 01, 2000
ISBN	: 0-7897-2468-5
Pages	: 1152
Slots	: 1			Copyright
		About the Authors
		Acknowledgments
			Tell Us What You Think!
		Introduction
			This Book Is for You
			How This Book Is Organized
			Conventions Used in This Book
		Part I:   The Java Language
			Chapter  1.   Object-Oriented Programming
				Object-Oriented Programming: A Different Way of Thinking
				A Short History of Programming
				A Lesson in Objects
				Objects as Multiple Entities
				Modularity and Code Organization
				Relating Objects to Java Classes
				Building a Hierarchy: Steps in OOP Design
				OOP and the UML
				Is Java a Magic OOP Bullet?
			Chapter  2.   HelloWorld: Your First Java Program
				HelloWorld Application
				Understanding HelloWorld
				HelloWorld as an Applet
				Keywords
				The Java 1.3 API
				Troubleshooting
			Chapter  3.   Data Types and Other Tokens
				Java Data Types
				Working with Variables
				The boolean Primitive
				The Flavors of Integer
				Operators
				Character Variables
				Floating-Point Variables
				Literals: Assigning Values
				Integer Literals
				Character Literals
				Floating-Point Literals
				String Literals
				Arrays
				Non-Token Input Elements
				Troubleshooting
			Chapter  4.   Methods and Exceptions
				Declaring a Method
				Blocks and Statements
				Methods and the UML Sequence Diagram
				Catching and Throwing Exceptions
				Java's Error Classes
				Troubleshooting
			Chapter  5.   Using Expressions
				What Is an Expression?
				How Expressions Are Evaluated
				Of Special Interest to C Programmers
				Bitwise Operators
				Shift Operators
				Type Conversions
				Special Operator Support for Strings
				Troubleshooting
			Chapter  6.   Control Flow
				Controlling the Flow of Execution
				Boolean Operators
				Logical Expressions
				The Conditional Operator
				Booleans in Control Flow Statements
				Control Flow Functions
				switch Statements
				Iteration Statements
				Jump Statements
				Troubleshooting
			Chapter  7.   Classes
				What Are Classes?
				Why Use Classes?
				Classes in Java
				Declaring a Class
				Variables ”Defining State
				Methods ”Defining Behavior
				Creating an Instance of a Class
				Referring to Class Elements
				The Object Class
				Casting and Converting Reference Types
				Inner Classes
				Packages
				Wrapping the Primitive Types in Classes
				Using the Standard Mathematical Functions
				Building a UML Class Diagram
				Troubleshooting
			Chapter  8.   Using Strings and Text
				Introducing Strings
				Using the String Class
				Getting Information About a String Object
				Comparing Strings
				String Extraction
				String Manipulation
				Concatenating Strings
				Converting Objects to Strings
				Converting Primitives to Strings
				Using the StringBuffer Class
				Using the StringTokenizer Class
				Strings and the Compiler
				Troubleshooting
			Chapter  9.   Interfaces
				What Are Interfaces?
				Defining an Interface
				Implementing an Interface
				Referencing Interfaces
				Choosing Between an Interface and an Abstract Class
				Depicting Interfaces in UML
				Troubleshooting
			Chapter  10.   Data Structures and Java Utilities
				Collection and Utility Classes
				The Collections Framework
				Collection Interfaces
				In the Beginning
				General-Purpose Implementations
				Sorting a Collection
				Iterating a Collection
				Collection Utilities and Wrappers
				Which Collection Class to Use?
				Array Utilities
				Configuring an Application Using the Properties Class
				Working with Dates
				The BitSet Class
				Generating Random Numbers
				Monitoring State Changes Using Observer / Observable
				Troubleshooting
			Chapter  11.   Threads
				What Are Threads?
				Why Use Threads?
				How to Make Your Classes Threadable
				Extending Thread
				Implementing Runnable
				The Life Cycle of a Thread
				Using Thread Local Variables
				Changing Thread Priorities
				Thread Synchronization
				Changing the Running State of a Thread
				Thread Groups
				Obtaining the Number of Running Threads
				Yielding to Other Threads
				Daemon Threads
				Using the Timer and TimerTask Classes
				Making Your Application Thread-Safe
				Troubleshooting
		Part II:   User Interface
			Chapter  12.   Introduction to Java Foundation Classes
				What Is the JFC?
				History of the JFC
				JFC Applications
				Applets
				Troubleshooting
				Playing Audio Clips from a JFC Application
				Launching a Frame from an Applet
			Chapter  13.   Beginning AWT
				What Is the AWT?
				Graphics
				Fonts and Colors
				Images
				Troubleshooting
			Chapter  14.   Building a GUI: AWT Style
				Introducing the Windowing Toolkit
				Building a GUI: Components, Containers, and Layout Managers
				Building a GUI: Events and Listeners
				Customizing the Windowing Toolkit
				Troubleshooting
			Chapter  15.   And Then There Was Swing
				What Is Swing?
				Comparing Swing to the AWT
				Mixing Heavyweight and Lightweight Components
				Converting from the AWT to Swing
				Troubleshooting
			Chapter  16.   Building a GUI: Swing Style
				A Swinging Toolkit
				Building a GUI: Components, Containers, and Layout Managers
				Building a GUI: Events and Listeners
				Odds and Ends
				Troubleshooting
			Chapter  17.   Accessibility
				What Is Accessibility?
				How Does Accessibility Work?
				Utilities
				Robots
				Troubleshooting
			Chapter  18.   Java 2D
				What Is Java 2D?
				Rendering 101
				Shapes, Text, and Buffered Images
				Printing
				Troubleshooting
			Chapter  19.   Drag and Drop
				What Is Drag and Drop?
				First Comes Data Transfer
				Then Comes Drag and Drop
				Troubleshooting
			Chapter  20.   Java Media Framework
				What Is JMF?
				Playing Media
				Processing Media
				Capturing Media
				Troubleshooting
		Part III:   I/O
			Chapter  21.   Streams, Files, and Serialization
				What Are Streams?
				Working with the Stream Classes
				Reading and Writing Data Using Byte Streams
				Redirecting Standard Input/Output
				Using Readers and Writers
				Working with Files
				Creating Files
				Reading and Writing Files
				Directory Operations
				Object Streams
				Troubleshooting
			Chapter  22.   Object Serialization
				What Is Object Serialization?
				Object Serialization Example
				Reading and Writing Your Own Objects
				Customizing Object Serialization
				Using the Externalizable Interface
				Troubleshooting
			Chapter  23.   Communications and Networking
				Overview of Network Communications
				TCP/IP Architecture
				Working with Sockets
				Compressing Data When Using Sockets
				Sending Objects Across the Network Using Sockets
				Obtaining Hostname and IP Address Information
				User Datagram Protocol (UDP)
				World Wide Web Overview
				Understanding the Request/Response Scenario
				Using the URL Classes
				An Example: Building a World Wide Web Graph
				HTTP and SSL
				Java Secure Socket Extension Package Overview
				Troubleshooting
			Chapter  24.   Using Internationalization
				What Is Internationalization?
				Java Support for Internationalization
				The Locale Class
				Packaging Locale-Sensitive Data
				Calendar and Time Zone Support
				Internationalization Formatting
				Character Set Converters
				Readers and Writers
				The java.text Package
				An Example: InternationalizationTest
				Troubleshooting
			Chapter  25.   JAR Files
				Using JAR Files
				Some Differences Between ZIP and JAR Formats
				Creating and Viewing a JAR
				The Manifest File
				Reading and Writing JAR Files
				Adding a JAR to Your Classpath
				JAR s and Security
				When to Use JAR s
				Troubleshooting
		Part IV:   Databases
			Chapter  26.   JDBC 2.0 Fundamentals
				What Is the JDBC?
				JDBC 2.0 Overview
				JDBC Drivers
				Setting Up a Database
				Installing and Using a JDBC Driver
				JDBC URLs
				Connecting to the Database
				Reading Data Using JDBC
				Writing Data Using JDBC
				Using Prepared Statements
				Using Transactions
				Getting MetaData from the Database
				Using Stored Procedures
				Troubleshooting
			Chapter  27.   Advanced JDBC 2.0
				New Features in JDBC 2.0 API
				Using the JDBC Optional Package
				Understanding Object-to-Relational Mapping Frameworks
				Troubleshooting
		Part V:   Component Development
			Chapter  28.   Reflection
				What Is Reflection?
				Key Classes of the Reflection API
				Security Considerations
				Creating a Class Knowing Only the List of Constructors
				Inspecting a Class for Its Methods
				Accessing the Declared Fields of a Class
				Utility Methods
				Implementing an Interface Using a Proxy
				Troubleshooting
			Chapter  29.   JavaBeans
				Self-Contained Components
				Important Concepts in Component Models
				The Basics of Designing a JavaBean
				Creating and Using Properties
				Using Events to Communicate with Other Components
				Introspection: Creating and Using BeanInfo Classes
				Customization: Providing Custom PropertyEditors and GUI Interfaces
				Bean Packaging
				Enterprise JavaBeans
				Troubleshooting
		Appendix A.   Installing the SDK and Getting Started
			Getting the SDK 1.3SE
			Installing the SDK 1.3SE
			Testing the Java Compiler and JVM
		Appendix B.   SDK Tools
			SDK Tools Reference
			AppletViewer
			java ” The Java Interpreter
			javac ” The Java Compiler
			javap ”The Java Disassembler
			The javadoc Tool (Documentation Generator)
			jdb ”The Java Debugger
		Appendix C.   SDK 1.3 Performance Improvements
			General Performance Improvements
			Introduction to HotSpot Technology
			What Makes HotSpot Better?
			Java HotSpot Client Virtual Machine
			Java HotSpot Server Virtual Machine 2.0
			Applet Deployment Improvements
		Appendix D.   Java Resources
			Web Sites
			Newsgroups
			Mailing Lists
		Index