Learning Java Learning Java Preface Who Should Read This Book New Developments New in This Edition (Java 6 and 7) Using This Book Online Resources Conventions Used in This Book Using Code Examples Safari® Books Online How to Contact Us Acknowledgments 1. A Modern Language Enter Java Java’s Origins Growing Up A Virtual Machine Java Compared with Other Languages Safety of Design Simplify, Simplify, Simplify... Type Safety and Method Binding Incremental Development Dynamic Memory Management Error Handling Threads Scalability Safety of Implementation The Verifier Class Loaders Security Managers Application and User-Level Security A Java Road Map The Past: Java 1.0–Java 1.6 The Present: Java 7 The Future Availability 2. A First Application Java Tools and Environment Configuring Eclipse and Creating a Project Importing the Learning Java Examples HelloJava Classes The main() Method Classes and Objects Variables and Class Types HelloComponent Inheritance The JComponent Class Relationships and Finger Pointing Package and Imports The paintComponent() Method HelloJava2: The Sequel Instance Variables Constructors Events The repaint() Method Interfaces HelloJava3: The Button Strikes! Method Overloading Components Containers Layout Subclassing and Subtypes More Events and Interfaces Color Commentary Static Members Arrays Our Color Methods HelloJava4: Netscape’s Revenge Threads The Thread Class The Runnable Interface Starting the Thread Running Code in the Thread Exceptions Synchronization 3. Tools of the Trade JDK Environment The Java VM Running Java Applications System Properties The Classpath javap The Java Compiler JAR Files File Compression The jar Utility JAR manifests Making a JAR file runnable The pack200 Utility Policy Files The Default Security Manager The policytool Utility Using a Policy File with the Default Security Manager 4. The Java Language Text Encoding Comments Javadoc Comments Javadoc as metadata Types Primitive Types Floating-point precision Variable declaration and initialization Integer literals Floating-point literals Binary literals Character literals Reference Types A Word About Strings Statements and Expressions Statements if/else conditionals do/while loops The for loop The enhanced for loop switch statements Enumerations and switch statements break/continue Unreachable statements Expressions Operators Assignment The null value Variable access Method invocation Object creation The instanceof operator Exceptions Exceptions and Error Classes Exception Handling Bubbling Up Stack Traces Checked and Unchecked Exceptions Throwing Exceptions Chaining and rethrowing exceptions Narrowed rethrow try Creep The finally Clause Try with Resources Performance Issues Assertions Enabling and Disabling Assertions Using Assertions Arrays Array Types Array Creation and Initialization Using Arrays Anonymous Arrays Multidimensional Arrays Inside Arrays 5. Objects in Java Classes Accessing Fields and Methods Static Members Constants versus enumerations Methods Local Variables Shadowing The “this” reference Static Methods Initializing Local Variables Argument Passing and References Wrappers for Primitive Types Autoboxing and Unboxing of Primitives Performance implications of boxing Variable-Length Argument Lists Method Overloading Object Creation Constructors Working with Overloaded Constructors Static and Nonstatic Initializer Blocks Object Destruction Garbage Collection Finalization Weak and Soft References Enumerations Enum Values Customizing Enumerations 6. Relationships Among Classes Subclassing and Inheritance Shadowed Variables Overriding Methods @Override Overridden methods and dynamic binding Static method binding final methods and performance Compiler optimizations Method selection revisited Exceptions and overridden methods Return types and overridden methods Special References: this and super Casting Casting aspersions Using Superclass Constructors Full Disclosure: Constructors and Initialization Abstract Methods and Classes Interfaces Interfaces as Callbacks Interface Variables Flag interfaces Subinterfaces Overlapping and conflicting methods Packages and Compilation Units Compilation Units Package Names Class Visibility Importing Classes The unnamed package Static imports Visibility of Variables and Methods Basic Access Modifiers Subclasses and Visibility Interfaces and Visibility Arrays and the Class Hierarchy ArrayStoreException Inner Classes Inner Classes as Adapters Inner Classes Within Methods Limitations on inner classes in methods Static inner classes Anonymous inner classes Scoping of the “this” reference How do inner classes really work? Security implications 7. Working with Objects and Classes The Object Class Equality and Equivalence Hashcodes Cloning Objects The Class Class Reflection Modifiers and Security Accessing Fields Accessing Methods Accessing Constructors What About Arrays? Accessing Generic Type Information Accessing Annotation Data Dynamic Interface Adapters What Is Reflection Good For? The BeanShell Java scripting language Annotations Using Annotations Package annotations Standard Annotations The apt Tool 8. Generics Containers: Building a Better Mousetrap Can Containers Be Fixed? Enter Generics Talking About Types “There Is No Spoon” Erasure Raw Types Parameterized Type Relationships Why Isn’t a List<Date> a List<Object>? Casts Writing Generic Classes The Type Variable Subclassing Generics Exceptions and Generics No generic throwables Parameter Type Limitations Using Class<T> Bounds Erasure and Bounds (Working with Legacy Code) Wildcards A Supertype of All Instantiations Bounded Wildcards Thinking Outside the Container Lower Bounds Reading, Writing, and Arithmetic <?>, <Object>, and the Raw Type Wildcard Type Relationships Generic Methods Generic Methods Introduced Type Inference from Arguments Type Inference from Assignment Context Explicit Type Invocation Wildcard Capture Wildcard Types Versus Generic Methods Arrays of Parameterized Types Using Array Types What Good Are Arrays of Generic Types? Wildcards in Array Types Case Study: The Enum Class Case Study: The sort() Method Conclusion 9. Threads Introducing Threads The Thread Class and the Runnable Interface Creating and starting threads A natural-born thread Using an adapter Controlling Threads Deprecated methods The sleep() method The join() method The interrupt() method Death of a Thread Threading an Applet Issues Lurking Synchronization Serializing Access to Methods Accessing class and instance Variables from Multiple Threads Reentrant locking The wait() and notify() Methods Wait conditions Passing Messages Food for thought ThreadLocal Objects Scheduling and Priority Thread State Time-Slicing Priorities Yielding Thread Groups Working with ThreadGroups Uncaught Exceptions Thread Performance The Cost of Synchronization Thread Resource Consumption Concurrency Utilities Executors Tasks with results: Callable and Future ExecutorService Collective tasks Scheduled tasks CompletionService The ThreadPoolExecutor implementation Thread production The Fork/Join framework Locks Read and write locks Conditions Synchronization Constructs CountDownLatch Semaphore CyclicBarrier author="pat” timestamp="20120806T231934-0500” comment="I&apos;m not sure if we need to recast our example using Phaser or replace it... I think Phaser pretty much replaces CyclicBarrier, but it is only in Java 7... so normally we&apos;d show both... but they are very similar... Also I&apos;m tired :)”Phaser Exchanger Atomic Operations Weak implementations Field updaters Conclusion 10. Working with Text Text-Related APIs Strings Constructing Strings Strings from Things Comparing Strings The Collator class Searching Editing String Method Summary StringBuilder and StringBuffer Internationalization The java.util.Locale Class Resource Bundles Parsing and Formatting Text Parsing Primitive Numbers Working with alternate bases Number formats Tokenizing Text StringTokenizer Printf-Style Formatting Formatter The Format String String Conversions Width, precision, and justification Uppercase Numbered arguments Primitive and Numeric Conversions Flags Miscellaneous Formatting with the java.text Package MessageFormat Regular Expressions Regex Notation Write once, run away Escaped characters Characters and character classes Custom character classes Position markers Iteration (multiplicity) Grouping Capture groups Numbering Alternation Special options Greediness Lookaheads and lookbehinds The java.util.regex API Pattern The Matcher Splitting and tokenizing strings Another look at Scanner Replacing text Using captured text in a replacement Controlling the substitution Our simple template engine 11. Core Utilities Math Utilities The java.lang.Math Class Big/Precise Numbers Floating-Point Components Random Numbers Dates and Times Working with Calendars Time Zones Locale Parsing and Formatting with DateFormat Printf-Style Date and Time Formatting Timers Collections The Collection Interface Generics and collections Legacy code and runtime type safety Converting between collections and arrays Iterator For loop over collections java.util.Enumeration Collection Types Set List Queue BlockingQueue The Map Interface ConcurrentMap Collection Implementations Arrays Linked lists Trees Hash maps Java Collections implementations Hash Codes and Key Values Synchronized and Unsynchronized Collections Synchronizing iterators ConcurrentHashMap and ConcurrentLinkedQueue Read-Only and Read-Mostly Collections Copy-on-write (“read-mostly”) collections WeakHashMap EnumSet and EnumMap Sorting Collections A Thrilling Example Properties Loading and Storing System Properties The Preferences API Preferences for Classes Preferences Storage Change Notification The Logging API Overview Loggers Handlers Filters Formatters Logging Levels A Simple Example Logging Setup Properties The Logger Performance Observers and Observables 12. Input/Output Facilities Streams Basic I/O Character Streams Stream Wrappers Data streams Buffered streams PrintWriter and PrintStream Pipes Streams from Strings and Back Implementing a Filter Stream File I/O The java.io.File Class File constructors Path localization File operations File Streams RandomAccessFile Resource Paths The NIO File API FileSystem and Path Path to classic file and back NIO File Operations Directory Operations Watching Paths Serialization Initialization with readObject() SerialVersionUID Data Compression Archives and Compressed Data Zip archives Decompressing Data Zip Archive As a Filesystem The NIO Package Asynchronous I/O Performance Mapped and Locked Files Channels Buffers Buffer operations Buffer types Byte order Allocating buffers Character Encoders and Decoders CharsetEncoder and CharsetDecoder FileChannel Concurrent access File locking Memory-mapped files Direct transfer AsynchronousFileChannel Scalable I/O with NIO 13. Network Programming Sockets Clients and Servers Clients Servers Sockets and security author="pat” timestamp="20120926T110720-0500” comment="one of those sections I hate to get rid of but is less relevant in terms of the example... should probably find a more modern example...”The DateAtHost Client The TinyHttpd Server Do French web servers speak French? Taming the daemon Room for improvement Socket Options SO_TIMEOUT TCP_NODELAY SO_LINGER TCP_KEEPALIVE Half-close Proxies and Firewalls ProxySelector Datagram Sockets author="pat” timestamp="20120926T141346-0500” comment="I actually rewrote this as a standalone client but then decided to leave it as an applet”The HeartBeat Applet The HeartBeat applet code The Pulse server code InetAddress Simple Serialized Object Protocols A Simple Object-Based Server Limitations Remote Method Invocation Real-World Usage Remote and Nonremote Objects Remote interfaces Exporting remote objects The RMI registry An RMI Example Running the example Dynamic class loading Passing remote object references RMI and CORBA Scalable I/O with NIO Selectable Channels Using Select LargerHttpd Nonblocking Client-Side Operations 14. Programming for the Web Uniform Resource Locators (URLs) The URL Class Stream Data Getting the Content as an Object Managing Connections Handlers in Practice Useful Handler Frameworks Talking to Web Applications Using the GET Method Using the POST Method The HttpURLConnection SSL and Secure Web Communications URLs, URNs, and URIs Web Services XML-RPC WSDL The Tools The Weather Service Client 15. Web Applications and Web Services Web Application Technologies Page-Oriented Versus “Single Page” Applications JSPs XML and XSL Web Application Frameworks Google Web Toolkit HTML5, AJAX, and More... Java Web Applications The Servlet Lifecycle Servlets The HelloClient Servlet ServletExceptions Content type The Servlet Response Servlet Parameters GET, POST, and “extra path” GET or POST: Which one to use? The ShowParameters Servlet User Session Management The ShowSession Servlet The ShoppingCart Servlet Cookies The ServletContext API Asynchronous Servlets WAR Files and Deployment Configuration with web.xml and Annotations URL Pattern Mappings Deploying HelloClient Reloading web apps Error and Index Pages Security and Authentication Protecting Resources with Roles Secure Data Transport Authenticating Users Procedural Authorization Servlet Filters A Simple Filter A Test Servlet Declaring and Mapping Filters Filtering the Servlet Request Filtering the Servlet Response Building WAR Files with Ant A Development-Oriented Directory Layout Deploying and Redeploying WARs with Ant Implementing Web Services Defining the Service Our Echo Service Using the Service Data Types Standard types Value data objects Conclusion 16. Swing Components Peers and Look-and-Feel The MVC Framework Painting Enabling and Disabling Components Focus, Please Other Component Methods Containers Layout Managers Insets Z-Ordering (Stacking Components) The revalidate() and doLayout() Methods Managing Components Listening for Components Windows, Frames and Splash Screens Other Methods for Controlling Frames Content Panes Desktop Integration Events Event Receivers and Listener Interfaces Event Sources Event Delivery Event Types The java.awt.event.InputEvent Class Mouse and Key Modifiers on InputEvents Mouse-wheel events Focus Events Event Summary Adapter Classes Dummy Adapters The AWT Robot! Multithreading in Swing 17. Using Swing Components Buttons and Labels HTML Text in Buttons and Labels Checkboxes and Radio Buttons Lists and Combo Boxes The Spinner Borders Menus Pop-Up Menus Component-Managed Pop Ups The JScrollPane Class The JSplitPane Class The JTabbedPane Class Scrollbars and Sliders Dialogs File Selection Dialog The Color Chooser 18. More Swing Components Text Components The TextEntryBox Application Formatted Text Filtering Input DocumentFilter Validating Data Say the Magic Word Sharing a Data Model HTML and RTF for Free Managing Text Yourself Focus Navigation Trees Nodes and Models Save a Tree Tree Events A Complete Example Tables A First Stab: Freeloading Round Two: Creating a Table Model Round Three: A Simple Spreadsheet Sorting and Filtering Printing JTables Desktops Pluggable Look-and-Feel Creating Custom Components Generating Events A Dial Component Model and View Separation 19. Layout Managers FlowLayout GridLayout BorderLayout BoxLayout CardLayout GridBagLayout The GridBagConstraints Class Grid Coordinates The fill Constraint Spanning Rows and Columns Weighting Calculating the weights of rows and columns Anchoring Padding and Insets Relative Positioning Composite Layouts Other Layout Managers Absolute Positioning 20. Drawing with the 2D API The Big Picture The Rendering Pipeline A Quick Tour of Java 2D Filling Shapes Drawing Shape Outlines Convenience Methods Drawing Text Drawing Images Transformations and rendering The Whole Iguana Filling Shapes Solid Colors Color Gradients Textures Desktop Colors Stroking Shape Outlines Using Fonts Font Metrics Displaying Images The Image Class Image Observers Preloading images Scaling and Size Drawing Techniques Double Buffering Limiting Drawing with Clipping Offscreen Drawing Printing 21. Working with Images and Other Media Loading Images ImageObserver MediaTracker ImageIcon ImageIO Producing Image Data Drawing Animations BufferedImage Anatomy Color Models Creating an Image Updating a BufferedImage Filtering Image Data How ImageProcessor Works Converting an Image to a BufferedImage Using the RescaleOp Class Using the AffineTransformOp Class Saving Image Data Simple Audio Java Media Framework 22. JavaBeans What’s a Bean? What Constitutes a Bean? The NetBeans IDE Installing and Running NetBeans Installing our example beans Creating a project and file The NetBeans workspace Properties and Customizers Event Hookups and Adapters Taming the Juggler Running the example Molecular Motion Binding Properties Constraining Properties Building Beans The Dial Bean Design Patterns for Properties Generating bean patterns in NetBeans Limitations of Visual Design Serialization Versus Code Generation Customizing with BeanInfo Getting Properties Information Getting events information Supplying icons Creating customizers and property editors Handcoding with Beans Bean Instantiation and Type Management Working with Serialized Beans Runtime Event Hookups with Reflection How it works BeanContext and BeanContextServices The Java Activation Framework Enterprise JavaBeans and POJO-Based Enterprise Frameworks 23. Applets The Politics of Browser-Based Applications Applet Support and the Java Plug-in The JApplet Class Applet Lifecycle The Applet Security Sandbox Trusted applets Getting Applet Resources Applet parameters Applet resources Driving the browser Inter-applet communication Applet persistence and navigation The <applet> Tag Attributes Parameters ¿Habla Applet? The Complete <applet> Tag Loading Class Files Packages appletviewer Java Web Start Conclusion 24. XML The Butler Did It A Bit of Background Text Versus Binary A Universal Parser The State of XML The XML APIs XML and Web Browsers XML Basics Attributes XML Documents Encoding Namespaces Validation HTML to XHTML SAX The SAX API JAXP SAX’s strengths and weaknesses Building a Model Using SAX Creating the XML file The model The SAXModelBuilder Test drive Limitations and possibilities XMLEncoder/Decoder DOM The DOM API Test-Driving DOM Generating XML with DOM JDOM XPath Nodes Predicates Functions The XPath API XMLGrep XInclude Enabling XInclude Validating Documents Using Document Validation DTDs XML Schema Simple types Complex types Generating Schema from XML samples The Validation API Alternative schema languages JAXB Code Binding and Generation Annotating Our Model Unmarshalling from XML Generating a Java Model from an XML Schema Generating an XML Schema from a Java Model Transforming Documents with XSL/XSLT XSL Basics Transforming the Zoo Inventory XSLTransform XSL in the Browser Web Services The End of the Book A. The Eclipse IDE The IDE Wars Getting Started with Eclipse Importing the Learning Java Examples Using Eclipse Getting at the Source The Lay of the Land Running the Examples Building the Ant-Based Examples Loner Examples Eclipse Features Coding Shortcuts Autocorrection Refactoring Diffing Files Organizing Imports Formatting Source Code Conclusion B. BeanShell: Java Scripting Running BeanShell Java Statements and Expressions Imports BeanShell Commands Scripted Methods and Objects Scripting Interfaces and Adapters Changing the Classpath Learning More . . . Glossary Index About the Authors Colophon Copyright