Amazing Books
Temporary Blank

Friday, June 18, 2010

Eclipse Cookbook











By Steve Holzner

Publisher : O'Reilly
Pub Date : June 2004
ISBN : 0-596-00710-8
Pages : 368

Eclipse is a powerful open source platform that gives Java developers a new way to approach development projects. In the Eclipse Cookbook, Java expert Steve Holzner demystifies Eclipse with practical recipes for more than 800 situations you may encounter--from deploying a web application automatically to reverse engineering compiled code, from re-naming all references to a class across multiple packages to initializing the SWT JNI libraries.

Steve Holzner, author of O'Reilly's introductory book on Eclipse, returns with the Eclipse Cookbook to help developers get the most of one of the premier development environments. Taking a task oriented approach, the book covers all they key areas of Eclipse and then some.

Starting with the absolute basics - downloading and installing - the book moves on very quickly to answer most of the questions that a new user inevitably asks when faced with Eclipse. The first chapter covers basic skills, which in this case means learning to navigate the multiple perspectives that the IDE offers, learning to create Java classes, edit, run and debug code.

The second chapter looks in more detail at navigating the different perspectives, views, options, toolbars and the rest. The emphasis is on how Eclipse works in terms of the different components on the screen. This is fairly standard stuff that can be picked up just through using the IDE, but it's good to have it down on paper in one place.

The next chapter looks specifically at the Java Development Toolkit (JDT). In addition to showing how to get the most out of the functionality Eclipse provides the Java developer in terms of code completion, refactoring, class/method creation and more, it also looks at how to speed up the JDT, how to create TODO tasks and so on. This is good stuff and there's much here that newer users in particular are bound to find useful.

Other chapters cover building and running code, testing and debugging, using Eclipse with CVS, using Ant, three solid chapters on SWT, using Tomcat and two chapters on creating plug-ins. While the book is organised into chapters, each of these is broken down into sections, one to a task. In all the book promises to cover 'over 175' tasks, but task is a very loose term in this context - it covers everything from downloading Eclipse or a CVS server to actual development tasks such as building run-time configurations, creating Java packages and so on.

There's a wealth of useful material covered in the book, though there's inevitably some cross-over with Holzner's other book. The writing is clear and the book is well-illustrated (in O'Reilly monochrome of course). Coverage of version 3.0 of Eclipse is included, and where some of the tasks are specific to this release it's flagged clearly in the text.

For the Eclipse newbie looking for a wide-ranging but solid introduction this is a good place to look. Having reviewed both of Holzner's books on the subject we'd say that this one has the slight edge on the first book, if only because the task oriented nature of this one makes it much easier to home in on the question you want an answer for. The is a book works as more than just an introduction, it makes for a handy reference too.


Copyright
Preface
What's Inside
Conventions Used in This Book
What You'll Need
Using Code Examples
We'd Like to Hear from You
Chapter 1. Basic Skills
Introduction
Section 1.1. Getting Eclipse
Section 1.2. Installing and Running Eclipse
Section 1.3. Understanding Your Workspace
Section 1.4. Running Multiple Eclipse Windows
Section 1.5. Creating a Java Project
Section 1.6. Managing Perspectives, Views, and Editors
Section 1.7. Mastering the Java Perspective
Section 1.8. Creating a Java Class
Section 1.9. Completing Code Automatically
Section 1.10. Running Your Code
Section 1.11. Running Code Snippets
Section 1.12. Fixing Syntax Errors Automatically
Section 1.13. Keeping Your Workspace Clear
Section 1.14. Recovering from Total Disaster
Chapter 2. Using Eclipse
Introduction
Section 2.1. Showing/Hiding Views
Section 2.2. Moving a View or Toolbar
Section 2.3. Accessing Any Project File
Section 2.4. Tiling Editors
Section 2.5. Maximizing Views and Editors
Section 2.6. Going Back to the Previous Editor
Section 2.7. Going Back to the Previous Edit Location
Section 2.8. Linking Views to Editors
Section 2.9. Reordering View and Editor Tabs
Section 2.10. Navigating from an Editor to a View
Section 2.11. Creating a Key Binding
Section 2.12. Displaying More Resource Information with Icons
Section 2.13. Using a Different Workspace
Section 2.14. Creating a Task
Section 2.15. Creating a Bookmark
Section 2.16. Creating a Fast View
Section 2.17. Customizing Help
Section 2.18. Restoring Deleted Resources
Section 2.19. Customizing a Perspective
Section 2.20. Restoring a Perspective
Section 2.21. Creating a New Perspective
Chapter 3. Java Development
Introduction
Section 3.1. Speeding Up the JDT Editor
Section 3.2. Creating a Java Project
Section 3.3. Creating Java Packages
Section 3.4. Creating a Java Class
Section 3.5. Creating a Java Method
Section 3.6. Overriding a Java Method
Section 3.7. Getting Method Parameter Hints
Section 3.8. Inserting Method Parameter Names
Section 3.9. Creating Getter/Setter Methods
Section 3.10. Creating Delegate Methods
Section 3.11. Surrounding Code with do/for/if/try/while Blocks
Section 3.12. Finding the Matching Brace
Section 3.13. Automatically Wrapping Strings
Section 3.14. Creating a Constructor
Section 3.15. Converting Constructors to Factory Methods
Section 3.16. Commenting Out a Section of Code
Section 3.17. Creating Working Sets
Section 3.18. Creating TODO Tasks
Section 3.19. Customizing Code Assist
Chapter 4. Refactoring, Building, and Launching
Introduction
Section 4.1. Renaming Elements
Section 4.2. Moving Elements
Section 4.3. Extracting and Implementing Interfaces
Section 4.4. Searching Code
Section 4.5. Comparing Files
Section 4.6. Comparing Files Against Local History
Section 4.7. Restoring Elements and Files from Local History
Section 4.8. Selecting the Java Runtime for Builds
Section 4.9. Running Your Code
Section 4.10. Building Your Code
Section 4.11. Using .jar and .class Files
Section 4.12. Setting the Launch Configuration
Chapter 5. Testing and Debugging
Introduction
Section 5.1. Installing JUnit
Section 5.2. Testing an Application with JUnit
Section 5.3. Starting a Debugging Session
Section 5.4. Setting a Breakpoint
Section 5.5. Stepping Through Your Code
Section 5.6. Running Until Encountering a Breakpoint
Section 5.7. Running to a Line of Code You Select
Section 5.8. Watching Expressions and Variables
Section 5.9. Setting a Hit Count for Breakpoints
Section 5.10. Configuring Breakpoint Conditions
Section 5.11. Creating Field, Method, and Exception Breakpoints
Section 5.12. Evaluating Expressions
Section 5.13. Assigning Values to Variables While Debugging
Section 5.14. Changing Code on the Fly
Chapter 6. Using Eclipse in Teams
Introduction
Section 6.1. Getting a CVS Server
Section 6.2. Creating a CVS Repository
Section 6.3. Connecting Eclipse to a CVS Repository
Section 6.4. Storing an Eclipse Project in a CVS Repository
Section 6.5. Committing Files to the CVS Repository
Section 6.6. Visually Labeling Files Under Version Control
Section 6.7. Examining the CVS Repository
Section 6.8. Checking Projects Out of a CVS Repository
Section 6.9. Updating Your Code from a CVS Repository
Section 6.10. Synchronizing Your Code with the CVS Repository
Section 6.11. Creating Code Patches
Section 6.12. Naming Code Versions
Section 6.13. Creating CVS Branches
Chapter 7. Eclipse and Ant
Introduction
Section 7.1. Connecting Ant to Eclipse
Section 7.2. Building an Eclipse Application Using Ant
Section 7.3. Catching Ant Build File Syntax Problems
Section 7.4. Using a Different Build File
Section 7.5. Using Your Own Version of Ant
Section 7.6. Setting Types and Global Properties
Section 7.7. Setting Ant Editor Options
Section 7.8. Setting Ant Arguments
Section 7.9. Using the Ant View
Section 7.10. Using Ant as an External Tool
Chapter 8. SWT: Text, Buttons, Lists, and Nonrectangular Windows
Introduction
Section 8.1. Working with SWT Widgets
Section 8.2. Creating an SWT Application
Section 8.3. Adding the Required SWT JAR Files to the Build Path
Section 8.4. Launching an SWT Application
Section 8.5. Positioning Widgets and Using Layouts
Section 8.6. Creating Button and Text Widgets
Section 8.7. Handling SWT Widget Events
Section 8.8. Creating List Widgets
Section 8.9. Creating Composite Widgets
Section 8.10. Creating Nonrectangular Windows
Section 8.11. Multithreading SWT Applications
Chapter 9. SWT: Dialogs, Toolbars, Menus, and More
Introduction
Section 9.1. Creating Message Boxes
Section 9.2. Creating Dialogs
Section 9.3. Creating Toolbars
Section 9.4. Embedding Buttons in Toolbars
Section 9.5. Handling Toolbar Events
Section 9.6. Embedding Combo Boxes, Text Widgets, and Menus in Toolbars
Section 9.7. Creating a Menu System
Section 9.8. Creating Text Menu Items
Section 9.9. Creating Image Menu Items
Section 9.10. Creating Radio Menu Items
Section 9.11. Creating Menu Item Accelerators and Mnemonics
Section 9.12. Enabling and Disabling Menu Items
Section 9.13. Creating Menu Separators
Section 9.14. Creating Tables
Section 9.15. Creating Table Columns
Section 9.16. Adding Check Marks to Table Items
Section 9.17. Enabling and Disabling Table Items
Section 9.18. Adding Images to Table Items
Section 9.19. Using Swing and AWT Inside SWT
Chapter 10. SWT: Coolbars, Tab Folders, Trees, and Browsers
Introduction
Section 10.1. Creating SWT Tab Folders
Section 10.2. Creating SWT Coolbars
Section 10.3. Adding Items to Coolbars
Section 10.4. Adding Drop-Down Menus to Coolbars
Section 10.5. Creating SWT Trees
Section 10.6. Handling Tree Events
Section 10.7. Adding Checkboxes to Tree Items
Section 10.8. Adding Images to Tree Items
Section 10.9. Creating SWT Browser Widgets
Chapter 11. JSP, Servlets, and Eclipse
Introduction
Section 11.1. Installing Tomcat
Section 11.2. Starting Tomcat
Section 11.3. Creating JSP Files
Section 11.4. Creating a Servlet
Section 11.5. Installing a Servlet in Tomcat
Section 11.6. Creating a Servlet in Place
Section 11.7. Editing web.xml in Place
Section 11.8. Avoiding Output Folder Scrubs
Section 11.9. Interfacing to JavaBeans
Section 11.10. Using a Tomcat Plug-in
Section 11.11. Creating WAR Files
Chapter 12. Creating Plug-ins: Extension Points, Actions, and Menus
Introduction
Section 12.1. Installing a Plug-in
Section 12.2. Creating plugin.xml
Section 12.3. Creating a Menu-Based Plug-in Using Wizards
Section 12.4. Testing Plug-ins with the Run-time Workbench
Section 12.5. Deploying a Plug-in
Section 12.6. Writing a Plug-in from a Skeleton
Section 12.7. Responding to User Actions in a Plug-in
Section 12.8. Creating a Plug-in Menu from Scratch
Section 12.9. Creating Actions
Section 12.10. Coding a Plug-in Action
Section 12.11. Automatically Adding a Plug-in to a Perspective
Chapter 13. Creating Plug-ins: Wizards, Editors, and Views
Introduction
Section 13.1. Creating a Plug-in That Supports Wizards and Editors
Section 13.2. Customizing a Wizard
Section 13.3. Customizing an Editor
Section 13.4. Creating a Plug-in That Supports Views
Section 13.5. Adding Items to a View
Section 13.6. Configuring a View's Actions
Colophon
Index

Download this book click here
Another books about Java Click here
Another books about Programming Language

No comments:

Post a Comment

Related Posts with Thumbnails
There was an error in this gadget

Put Your Ads Here!
There was an error in this gadget