You are previewing Eclipse.
O'Reilly logo
Eclipse

Book Description

Java programmers know how finicky Java can be to work with. An omitted semi-colon or the slightest typo will cause the Java command-line compiler to spew pages of annoying error messages across your screen. And it doesn't fix them--that's up to you: fix them, compile again, and hope that nothing goes wrong this time. Eclipse, the popular Java integrated development environment (IDE) provides an elegant and powerful remedy for this common, frustrating scenario. It doesn't just catch your errors before you compile, it also suggests solutions. All you need to do is point and click. And it's free--what could be better? Still, if you're like most programmers, mastering a new technology--no matter how productive it will make you in the long run--is going to take a chunk out of your productivity now. You want to get up to speed quickly without sacrificing efficiency. O'Reilly's new guide to the technology, Eclipse, provides exactly what you're looking for: a fast-track approach to mastery of Eclipse. This insightful, hands-on book delivers clear and concise coverage, with no fluff, that gets down to business immediately. The book is tightly focused, covering all aspects of Eclipse: the menus, preferences, views, perspectives, editors, team and debugging techniques, and how they're used every day by thousands of developers. Development of practical skills is emphasized with dozens of examples presented throughout the book. From cover-to-cover, the book is pure Eclipse, covering hundreds of techniques beginning with the most basic Java development through creating your own plug-in editors for the Eclipse environment. Some of the topics you'll learn about include:

  • Using Eclipse to develop Java code

  • Testing and debugging

  • Working in teams using CVS

  • Building Eclipse projects using Ant

  • The Standard Widget Toolkit (SWT)

  • Web development

  • Developing Struts applications with Eclipse

From basics to advanced topics, Eclipse takes you through the fundamentals of Eclipse and more. You may be an Eclipse novice when you pick up the book, but you'll be a pro by the time you've finished.

Table of Contents

  1. Eclipse
    1. SPECIAL OFFER: Upgrade this ebook with O’Reilly
    2. A Note Regarding Supplemental Files
    3. Preface
      1. What's Inside
      2. Conventions Used in This Book
      3. What You'll Need
      4. Using Code Examples
      5. We'd Like to Hear from You
    4. 1. Essential Eclipse
      1. 1.1. Eclipse and Java
        1. 1.1.1. Some Background
        2. 1.1.2. A Word About the Common Public License (CPL)
      2. 1.2. Getting Eclipse
      3. 1.3. Understanding Eclipse
        1. 1.3.1. The Eclipse Platform
        2. 1.3.2. The Platform Kernel
        3. 1.3.3. The Eclipse Workbench
        4. 1.3.4. The Eclipse Workspace
        5. 1.3.5. The Team Component
        6. 1.3.6. The Help Component
      4. 1.4. Views and Perspectives
      5. 1.5. Working with Eclipse
        1. 1.5.1. Creating a Java Project
        2. 1.5.2. Creating a Java Class
        3. 1.5.3. Using Code Assist
        4. 1.5.4. Running Your Code
        5. 1.5.5. Using the Scrapbook
      6. 1.6. Using Quick Fix
      7. 1.7. A Word About Project Management
    5. 2. Java Development
      1. 2.1. Developing Java Code
        1. 2.1.1. Creating New Methods
        2. 2.1.2. Creating New Classes
        3. 2.1.3. Creating New Packages
      2. 2.2. Building and Running Code
        1. 2.2.1. Using JAR and .class Files
        2. 2.2.2. Setting the Launch Configuration
        3. 2.2.3. Selecting the Java Runtime
      3. 2.3. Creating Javadoc
      4. 2.4. Refactoring
        1. 2.4.1. Renaming Elements
        2. 2.4.2. Moving Elements
        3. 2.4.3. Extracting Interfaces
      5. 2.5. Some Essential Skills
        1. 2.5.1. Viewing Type Hierarchies
        2. 2.5.2. Browsing Java Code
        3. 2.5.3. Searching Code
      6. 2.6. Customizing the Development Environment
    6. 3. Testing and Debugging
      1. 3.1. Testing with JUnit
        1. 3.1.1. Creating a Test Application
        2. 3.1.2. Installing JUnit
        3. 3.1.3. Testing an Application with JUnit
      2. 3.2. Debugging
        1. 3.2.1. A Buggy Program
        2. 3.2.2. Setting a Breakpoint
        3. 3.2.3. Stepping Through Code
        4. 3.2.4. Resuming Execution Until Encountering a Breakpoint
        5. 3.2.5. Setting Breakpoint Hit Counts
        6. 3.2.6. Configuring Breakpoints
          1. 3.2.6.1. Checking a condition
          2. 3.2.6.2. Multithreaded debugging
          3. 3.2.6.3. Watchpoints
          4. 3.2.6.4. Method breakpoints
          5. 3.2.6.5. Exception breakpoints
        7. 3.2.7. Evaluating Java Expressions and Changing Values
        8. 3.2.8. Using Hot Code Replacement
          1. 3.2.8.1. Targeting earlier JREs
    7. 4. Working in Teams
      1. 4.1. How Source Control Works
      2. 4.2. Understanding CVS
      3. 4.3. Finding a CVS Server
        1. 4.3.1. Creating a Repository
        2. 4.3.2. Connecting to CVS
      4. 4.4. Adding a Project to the CVS Repository
        1. 4.4.1. Creating a Repository Location
        2. 4.4.2. Sharing Projects
        3. 4.4.3. Committing Files
        4. 4.4.4. Checking Projects Out
        5. 4.4.5. Updating Code
        6. 4.4.6. Comparing Code with Local History
        7. 4.4.7. Committing Code
        8. 4.4.8. Synchronizing Code
        9. 4.4.9. Creating a Patch
        10. 4.4.10. Tagging Versions
        11. 4.4.11. Creating Branches
    8. 5. Building Eclipse Projects Using Ant
      1. 5.1. Working with Ant
      2. 5.2. JARing Your Output
      3. 5.3. Configuring Ant in Eclipse
      4. 5.4. Catching Errors in Build Files
    9. 6. GUI Programming: From Appletsto Swing
      1. 6.1. Creating AWT Applications
      2. 6.2. Creating Swing Applications
      3. 6.3. Using Eclipse Plug-ins
      4. 6.4. Using the V4ALL Plug-in
        1. 6.4.1. Adding a V4ALL Editor to a Project
        2. 6.4.2. Designing the GUI
        3. 6.4.3. Creating a Method
        4. 6.4.4. Generating and Editing the Code
        5. 6.4.5. Running the Result
    10. 7. SWT: Buttons, Text, Labels, Lists, Layouts, and Events
      1. 7.1. Java Graphics
        1. 7.1.1. AWT
        2. 7.1.2. Swing
        3. 7.1.3. SWT
      2. 7.2. An SWT Example
      3. 7.3. Working with Buttons
      4. 7.4. Working with Composites and Layouts
      5. 7.5. Working with Lists
      6. 7.6. Using V4ALL with SWT
    11. 8. SWT: Menus, Toolbars, Sliders, Trees, and Dialogs
      1. 8.1. Working with Menus
      2. 8.2. Working with Toolbars
      3. 8.3. Working with Sliders
      4. 8.4. Working with Trees
      5. 8.5. Working with Dialogs
      6. 8.6. Opening Internet Explorer in anSWT Window
    12. 9. Web Development
      1. 9.1. Installing and Testing Tomcat
      2. 9.2. Creating a JSP
      3. 9.3. Creating a Servlet
      4. 9.4. Creating a Servlet in Place
      5. 9.5. Connecting to a JavaBean
      6. 9.6. Using the Sysdeo Tomcat Plug-in
        1. 9.6.1. Writing JSP with the Sysdeo Tomcat Plug-in
        2. 9.6.2. Writing Servlets with the Sysdeo Tomcat Plug-in
        3. 9.6.3. Debugging Web Projects
      7. 9.7. Deploying Web Applications
    13. 10. Developing Struts Applicationswith Eclipse
      1. 10.1. Struts and Eclipse
      2. 10.2. Creating the View
      3. 10.3. Creating the Controller
      4. 10.4. Creating the Model
      5. 10.5. Using the Easy Struts Plug-in
    14. 11. Developing a Plug-in: The Plug-in Development Environment, Manifests, and Extension Points
      1. 11.1. All You Really Need Is plugin.xml
      2. 11.2. Using the Plug-in Development Environment
      3. 11.3. Using the Run-time Workbench
      4. 11.4. Creating a Standard Plug-in
        1. 11.4.1. Creating an Action Set
        2. 11.4.2. Creating a Menu
        3. 11.4.3. Creating an Action
        4. 11.4.4. Writing the Code
        5. 11.4.5. Automatically Customizing a Perspective
    15. 12. Developing a Plug-in: Creating Editors and Views
      1. 12.1. Creating a Multi-Page Editor
        1. 12.1.1. Creating the Code
        2. 12.1.2. Dissecting the Wizard
        3. 12.1.3. Coding a Multi-Page Editor
      2. 12.2. Creating a View
        1. 12.2.1. Adding Items to the View
        2. 12.2.2. Configuring View Actions
      3. 12.3. Deploying a Plug-in
    16. 13. Eclipse 3.0
      1. 13.1. A Look at Eclipse 3.0
      2. 13.2. Creating a Java Project
      3. 13.3. Changes to the Eclipse Platform
      4. 13.4. Changes to the Java Development Tools
        1. 13.4.1. Quick Hierarchy Views
        2. 13.4.2. Creating Constructors from Fields
        3. 13.4.3. Creating Factory Methods
        4. 13.4.4. Smart Insert Mode
        5. 13.4.5. Creating Block Comments
        6. 13.4.6. New Views
        7. 13.4.7. Additional Changes
      5. 13.5. Other Changes
    17. Index
    18. Colophon
    19. SPECIAL OFFER: Upgrade this ebook with O’Reilly