Table of Contents

NetBeans™ IDE Field Guide: Developing Desktop, Web, Enterprise, and Mobile Applications, Second Edition
By Patrick Keegan, Ludovic Champenois, Gregory Crawley, Charlie Hunt, Christopher Webster, John Jullion-Ceccarelli, Jiri Prazak, Martin Ryzl, Gregg Sporar, Geertjan Wielenga
...............................................
Publisher: Prentice Hall
Pub Date: May 09, 2006
Print ISBN-10: 0-13-239552-5
Print ISBN-13: 978-0-13-239552-6
Pages: 424

Table of Contents  | Index

		Copyright
		Foreword to the First Edition
		Foreword to the First Edition
		Preface
		About the Authors
		Acknowledgments for the Second Edition
		Acknowledgments for the First Edition
		Chapter 1.  Download, Installation, and First Project
			Downloading the IDE
			Installing the IDE
			Setting a Proxy
			First NetBeans IDE Project
		Chapter 2.  NetBeans IDE Fundamentals
			Creating a Project
			Configuring the Classpath
			Creating a Subproject
			Creating and Editing Files
			Setting Up and Modifying Java Packages
			Compiling and Building
			Viewing Project Metadata and Build Results
			Navigating to the Source of Compilation Errors
			Running
			Creating and Running Tests
			Debugging the Application
			Integrating Version Control Commands
			Managing IDE Windows
		Chapter 3.  IDE Project Fundamentals
			Introduction to IDE Projects
			Choosing the Right Project Template
			Creating a Project from Scratch
			Importing a Project Developed in a Different Environment
			Navigating Your Projects
			Working with Files Not in the Project
			Creating Packages and Files in the Project
			Configuring the Project's Classpath
			Changing the Version of the JDK Your Project Is Based On
			Changing the Target JDK for a Standard Project
			Referencing JDK Documentation (Javadoc) from the Project
			Adding Folders and JAR Files to the Classpath
			Making External Sources and Javadoc Available in the IDE
			Structuring Your Projects
			Displaying and Hiding Projects
			Compiling a Project
			Running a Project in the IDE
			Deploying a Java Project Outside of the IDE
			Building a Project from Outside of the IDE
			Customizing the IDE-Generated Build Script
			Running a Specific Ant Target from the IDE
			Completing Ant Expressions
			Making a Menu Item or Shortcut for a Specific Ant Target
		Chapter 4.  Versioning Your Projects
			Setting up CVS in NetBeans IDE
			Checking Out Sources from a CVS Repository
			Putting a Project into CVS
			Keeping Track of Changes
			Updating Files
			Committing Changes
			Ignoring Files in CVS Operations
			Adding and Removing Files from a Repository
			Working with Branches
			Working with Patches
			Working with Versioning Histories
			Working with Other Version Control Systems
		Chapter 5.  Editing and Refactoring Code
			Opening the Source Editor
			Managing Automatic Insertion of Closing Characters
			Displaying Line Numbers
			Generating Code Snippets without Leaving the Keyboard
			Using Code Completion
			Inserting Snippets from Code Templates
			Using Editor Hints to Generate Missing Code
			Matching Other Words in a File
			Generating Methods to Implement and Override
			Generating JavaBeans Component Code
			Creating and Using Macros
			Creating and Customizing File Templates
			Handling Imports
			Displaying Javadoc Documentation While Editing
			Formatting Code
			Text Selection Shortcuts
			Navigating within the Current Java File
			Navigating from the Source Editor
			Searching and Replacing
			Deleting Code Safely
			Changing a Method's Signature
			Encapsulating a Field
			Moving a Class to a Different Package
			Moving Class Members to Other Classes
			Creating a Method from Existing Statements
			Creating an Interface from Existing Methods
			Extracting a Superclass to Consolidate Common Methods
			Changing References to Use a Supertype
			Unnesting Classes
			Tracking Notes to Yourself in Your Code
			Comparing Differences Between Two Files
			Splitting the Source Editor
			Maximizing Space for the Source Editor
			Changing Source Editor Keyboard Shortcuts
		Chapter 6.  Building Java Graphical User Interfaces
			Using Different Layout Managers
			Placing and Aligning a Component in a Form
			Setting Component Size and Resizability
			Setting Component Alignment
			Specifying Component Behavior and Appearance
			Generating Event Listening and Handling Methods
			Customizing Generated Code
			Previewing a Form
			Using Custom Beans in the Form Editor
			Deploying GUI Applications Developed with Matisse
		Chapter 7.  Debugging Java Applications
			Starting a Debugging Session
			Attaching the Debugger to a Running Application
			Starting the Debugger Outside of the Project's Main Class
			Stepping through Code
			Setting Breakpoints
			Managing Breakpoints
			Customizing Breakpoint Behavior
			Monitoring Variables and Expressions
			Backing up from a Method to Its Call
			Monitoring and Controlling Execution of Threads
			Fixing Code During a Debugging Session
			Viewing Multiple Debugger Windows Simultaneously
		Chapter 8.  Developing Web Applications
			Representation of Web Applications in the IDE
			Adding Files and Libraries to Your Web Application
			Editing and Refactoring Web Application Files
			Deploying a Web Application
			Testing and Debugging Your Web Application
			Creating and Deploying Applets
			Changing the IDE's Default Web Browser
			Monitoring HTTP Transactions
		Chapter 9.  Creating Web Applications on the JSF and Struts Frameworks
			JSF Overview
			Struts Overview
		Chapter 10.  Introduction to Java EE Development in NetBeans IDE
			Configuring the IDE for Java EE Development
			Java EE Server Support
			Getting the Most from the Java BluePrints Solutions Catalog
		Chapter 11.  Extending Web Applications with Business Logic: Introducing Enterprise Beans
			EJB Project Template Wizards
			Adding Enterprise Beans, Files, and Libraries to Your EJB Module
			Adding Business Logic to an Enterprise Bean
			Adding a Simple Business Method
			Enterprise Bean Deployment Descriptors
		Chapter 12.  Extending Java EE Applications with Web Services
			Consuming Existing Web Services
			IDE and Server Proxy Settings
			Creating a WSDL File
			Implementing a Web Service in a Web Application
			Implementing Web Services within an EJB Module
			Testing Web Services
			Adding Message Handlers to a Web Service
		Chapter 13.  Developing Full-Scale Java EE Applications
			Creating Entity Beans with the Top-Down Approach
			Creating Entity Beans with the Bottom-Up Approach
			Assembling Enterprise Applications
			Importing Existing Enterprise Applications
			Consuming Java Enterprise Resources
			Java EE Platform and Security Management
			Understanding the Java EE Application Server Runtime Environment
			Ensuring Java EE Compliance
			Refactoring Enterprise Beans
			Database Support and Derby Integration
		Chapter 14.  Developing Java ME Mobile Applications
			Downloading and Installing the Mobility Pack
			Mobility Primer
			Configuration vs. Configuration
			Setting up Mobility Projects
			Creating a Project from Scratch
			Importing a Project
			Physical Structure of Mobile Projects
			Using Mobility File Templates
			Configuring the Project's Classpath
			Debugging Your Project
			Configuring Your Project for Different Devices
			Setting the Active Configuration for Your Project
			Reusing Project Settings and Configurations
			Structuring Project Dependencies
			Managing the Distribution JAR File Content
			Handling Project Resources for Different Configurations
			Writing Code Specific to a List of Configurations
			Using the Preprocessor
			Using Configuration Abilities
			Creating and Associating an Ability with a Configuration
			Localizing Applications
			Using the MIDP Visual Designer
			Understanding the Flow Designer
			Understanding the Screen Designer
			Deploying Your Application Automatically
			Incrementing the Application's MIDlet-Version Automatically
			Using Ant in Mobility Projects
			Using Headless Builds
			Using the Wireless Connection Tools
			Finding More Information
		Chapter 15.  Profiling Java Applications
			Supported Platforms
			Downloading and Installing the NetBeans Profiler
			Starting a Profiling Session
			The Profiler Control Panel
			Monitoring an Application
			Analyzing Performance
			Analyzing Code Fragment Performance
			Analyzing Memory Usage
			Attaching the Profiler to a JVM
		Chapter 16.  Integrating Existing Ant Scripts with the IDE
			Creating a Free-Form Project
			Mapping a Target to an IDE Command
			Setting up the Debug Project Command for a General Java Application
			Setting up the Debug Project Command for a Web Application
			Setting up Commands for Selected Files
			Setting up the Compile File Command
			Setting up the Run File Command
			Setting up the Debug File Command
			Setting up the Debugger's Apply Code Changes Command
			Setting up the Profile Project Command for a General Java Application
			Changing the Target JDK for a Free-Form Project
			Making a Custom Menu Item for a Target
			Debugging Ant Scripts
		Chapter 17.  Developing NetBeans Plug-in Modules
			Plug-in Modules
			Rich-Client Applications
			Extending NetBeans IDE with Plug-in Modules
			Setting up a Plug-in Module
			Using the NetBeans APIs
			Registering the Plug-in Module
			Adding a License to a Plug-in Module
			Building and Trying Out a Plug-in Module
			Packaging and Distributing a Plug-in Module
			Packaging and Distributing a Rich-Client Application
			Finding Additional Information
		Chapter 18.  Using NetBeans Developer Collaboration Tools
			Getting the NetBeans Developer Collaboration Tools
			Configuring NetBeans IDE for Developer Collaboration
			Creating a Collaboration Account
			Managing Collaboration Accounts
			Logging into a Collaboration Server
			Collaborating and Interacting with Developers
		Appendix A.  Importing an Eclipse Project into NetBeans IDE
			Getting the Eclipse Project Importer
			Choosing Between Importing with and Importing without Project Dependencies
			Importing an Eclipse Project and Preserving Project Dependencies
			Importing an Eclipse Project and Ignoring Project Dependencies
			Handling Eclipse Project Discrepancies
			Handling Eclipse Project Reference Problems
		Appendix B.  Importing a JBuilder Project into NetBeans IDE
			Getting the JBuilder Project Importer
			Importing a JBuilder 2005 Project
			Project Import Warnings
			Running the Imported Project
		Index