1. Introduction to Eclipse
Ed Gehringer
Using (with permission) slides developed by—
Dwight Deugo
Nesa Matic
Portions of the notes for this lecture include excerpts from the Eclipse Help facility. These excerpts are made available under CPL for ease of use by instructors, (c) Copyright (c) 2000, 2003 IBM Corporation and others. For more complete information instructors are encouraged to read the full notes from the Eclipse Help facility.

2. Overview Overview Installing and Running
Building and Running Java Classes
Debugging
Let’s begin with an overview of Eclipse.

3. Module Road Map Overview Background Architecture Components
Usage scenarios
Installing and Running
Building and Running Java Classes
Debugging
Let’s begin with an overview of Eclipse.

4. What is Eclipse? Eclipse is an open source project
Consortium of companies, including IBM
Launched in November 2001
Designed to help developers with specific development tasks
Consists of four separate projects:
Eclipse Project
Eclipse Tools Project
Eclipse Technology Project
Eclipse Web Tools Platform Project
The Eclipse Project was designed to provide a platform for building of highly integrated development tools. It was initiated by IBM with a consortium of companies, which now include companies such as Borland, Fujitsu, HP, Hitachi, Object Management Group, Oracle, Parasoft, QNX Software Systems, Red Hat, SAP, and Sybase, in 2001.
The Eclipse Tools Project is designed to support building of variety of tools for The Eclipse Project. It provides single point of access to all tool developers to avoid overlapping and duplication in developing Eclipse tools.
The Eclipse Technology Project is designed to provide mechanism for on-going evaluation of Eclipse to developers, researchers, academics and educators.

5. IBM’s IDE History 1994 VisualAge for Smalltalk 1996
VisualAge for Java
VisualAge Micro Edition
In 1994 IBM has released VisualAge for Smalltalk, an IDE written in Smalltalk, meant to be used for developing Smalltalk applications.
When Java became popular, IBM has released VisualAge for Java, a Java IDE that was written in Smalltalk as well. Soon, the IDE gained great popularity.
In 2001 IBM has started Java based open-source initiative called Eclipse.
2001
Eclipse Project

6. The Eclipse Platform Motivation
Application development tools construction support
Independent tool vendors support
GUI and non-GUI application development support
Numerous content types support
Java, HTML, C, XML, ...
Easy integration of tools
Use of Java language for writing the tools
Multiple operating systems support

7. Plug-in Architecture … Eclipse Platform Tool (plug-in) Workbench Help
Workspace
Team
Tool
(plug-in)
The picture on this slide represents the high-level architecture of the Eclipse Platform.
All plug-ins must be added to the platform before it’s started. When platform is started, the Platform Runtime figures out what plug-ins are available and creates plug-in in-memory registry.
Team and Help on the picture represent existing “hooks” in Eclipse for adding help and team support to the applications and environment.
The Platform has 2 main components: the Workbench and the Workspace. The Workbench represents set of tools available for the user in the Eclipse environment and Workspace represents set of user defined components (projects, packages, classes, and more).
Platform Runtime

8. Workbench Represents the desktop development environment
It contains set of tools for resource management
It provides common way of navigating through the resources
Multiple workbenches can be opened at the same time
The term Workbench refers to the desktop development environment. The Workbench aims to achieve seamless tool integration and controlled openness by providing a common paradigm for the creation, management, and navigation of Workbench resources.
Each Workbench window contains one or more perspectives.  Perspectives contain views and editors and control what appears in certain menus and tool bars.  More than one Workbench window can exist on the desktop at any given time.

9. Workspace Represents users data It is a set of user-defined resources
Files
Contain arbitrary number of bytes
Folders
Contain other folders or files
Projects
Collections of files and folders
The central hub for your user's data files is called a workspace. You can think of the platform workbench as a tool that allows a user to navigate and manipulate the workspace. The resources plug-in provides APIs for creating, navigating, and manipulating resources in a workspace. The workbench uses these APIs to provide this functionality to the user. Your plug-in can also use these APIs.
From the standpoint of a resource-based plug-in, there is exactly one workspace, and it is always open for business as long as the plug-in is running. The workspace gets opened automatically when the resources plug-in is activated, and closed when the platform is shut down. If your plug-in requires the resources plug-in, then the resources plug-in will be started before your plug-in, and the workspace will be available to you.
The workspace contains a collection of resources. From the user's perspective, there are three different types of resources: projects, folders, and files. A project is a collection of any number of files and folders. It is a container for organizing other resources that relate to a specific area. Files and folders are just like files and directories in the file system. A folder contains other folders or files. A file contains an arbitrary sequence of bytes. Its content is not interpreted by the platform.
A workspace's resources are organized into a tree structure, with projects at the top, and folders and files underneath. A special resource, the workspace root resource, serves as the root of the resource tree. The workspace root is created internally when a workspace is created and exists as long as the workspace exists.
A workspace can have any number of projects.
Files and folders are similar to files and directories in the file system.
In the picture above we see MyServlet and MyWeb defined as projects and we see an images folder containing two files: .project and index.html

10. Help Used for creating and publishing documentation
There are two different documentation styles:
Help style documentation is published in the user guide
API documentation is published in the programmer guide
Help content is in HTML format
Help navigation is in XML format
The online help system provides access to the documentation, and lets you browse, search, and print it. The documentation is organized into sets of information that are roughly analogous to books. These, along with a full-text search engine and context-sensitive interface help, are designed to help you find the information you need.
The Eclipse platform's help facilities provide you with the raw building blocks to structure and contribute documentation to the platform. It does not dictate structure or granularity of documentation. You can choose the tools and structure for your documentation that suits your needs.  The help plug-in allows you to describe your documentation structure to the platform using a table of contents (toc) file.
Your plug-in's online help is contributed using the org.eclipse.help.toc extension point. You can either contribute the online help as part of your code plug-in or provide it separately in its own documentation plug-in.

11. Team Provides support for:
Versioning
Configuration management
Integration with team repository
Allows team repository provider to hook into the environment
Team repository providers specify how to intervene with resources
Has optimistic and pessimistic locking support
The Eclipse Platform provides basic hooks for plugging team repository into the environment. There are different workflows for different team repository providers, and the platform lets providers to make decisions how resource management will be implemented.
Support for CVS is built in. Just connect to a CVS server from the connection dialog, and you are all set.
In the pessimistic model, user checks out the resource and than the resource is locked for everybody else.
In the optimistic model, user can modify the resource while somebody else is modifying it as well. This usually results into manual intervention of modified resource – merging of two resource modifications.

12. How is Eclipse Used? As an IDE - Integrated Development Environment
Supports the manipulation of various content types
Used for writing code
As a product base
Supported through plug-in architecture and customizations

13. Eclipse as an IDE
Java Development Tooling (JDT) is used for building Java code
Provides set of workbench plug-ins for manipulating Java code
Java projects, packages, classes, methods, ....
Java compiler is built in
Used for compiling Java code
Creates errors (special markers of code) if compilation fails
Java Development Tooling provides set of plug-ins used for writing Java code. These plug-ins help in creating Java projects, packages, classes, methods, variables, and debugging code. Together they make a robust Java IDE.

14. Eclipse as a Product Base
Eclipse can be used as a Java product base
Its flexible architecture used as a product framework
Reuse plug-in architecture
Create new plug-ins
Customize the environment
When you use Eclipse as a product platform, you add your new features as plug-in to the standard directories of Eclipse: ..eclipse\plugins, and …eclipse\features. You then update the install.ini file to identify your primary features you use eclipse.exe to start the user interface. More details steps are identified in other modules.

15. Module Road Map Installing and Running Eclipse Overview
Where to get Eclipse?
What is the support for Eclipse?
Installing Eclipse
Running Eclipse
3. Building and Running Java Classes
4. Debugging
Let’s look at installing and running Eclipse.

16. Getting Eclipse
You can download eclipse by going to the Eclipse’s home page:

17. http://www.eclipse.org Main point for finding Eclipse resources
Downloads
Articles
Discussion groups
Bugs
Contains various resources for using Eclipse
Contains references to other Eclipse related sites
The Eclipse.org web page is your main source for finding and accessing Eclipse resource: downloads, articles, discussion groups, bug reports, and other references.

18. Downloading Eclipse’s Install Zip File
Click on the Download from the main page on
Choose the closest site from which to download (geographical sites hosting the download)
Choose the build for download (usually the latest build)
Choose the platform for download and type of download (http or ftp)
Specify where to save the download locally
The download web page has many options for you to select from. These options include the closest download site, the build version, and the platform. Before the download begins, you will also be asked the name of the local directory to store the install zip file.

19. Installing Eclipse
Unzip the downloaded file to the directory of your choice
To install Eclipse, unzip the download file (eclipse-SDK-2.1-win32.zip) to a directory of your choice.

20. eclipse.exe Eclipse is run by double-clicking on the eclipse.exe file
The file is located in the Eclipse installation directory
If there is no path set for javaw.exe program, the following dialog will come up
Eclipse is run by double-click on the eclipse.exe program that is located in the Eclipse installation directory, i.e. in the directory where downloaded zip file is unzipped.
If you don’t have Java Virtual Machine (JVM) set up in your path, a dialog will come up indicating that no JVM was found for running Eclipse. If you are missing a JVM, see the next slide.

21. Missing a Java VM? …
Download the latest Java Runtime Environment (JRE), e.g., v1.4.1_02 from
Click on the downloaded EXE file to install
When given the option by the installer, identify a directory of your choice for the install files
Update the PATH environment variable to include the JRE’s bin directory
One can download the latest Java Runtime Environment (JRE), e.g., v1.4.1_02, using the links found at Once the JRE’s “exe” file is downloaded, simply click on it to install. When given the option by the installer, identify a directory of your choice for the install files.
Once the installation has completed, you will need to update the PATH environment variable to include the JRE’s “bin” directory.

22. Specifying JVM There are two ways of specifying JVM for Eclipse:
By installing JVM under the \jre\ directory off the eclipse install directory
By specifying existing JVM in the PATH environment variable
Start -> Control Panel -> System ->Advanced -> Environment Variables
If JVM is already installed on the local system, simply set the PATH environment variable to indicate to the Eclipse where to find JVM.
If a JVM specific to Eclipse need to be used, it might be better idea to have it under \jre\ directory of the Eclipse installation directory.

23. Running Eclipse When Eclipse is run, a Workbench opens
Double click on the eclipse.exe found in the Eclipse install directory to run Eclipse and see the opening Workspace.

24. Default Workspace
The default workspace is created when Eclipse runs for the first time
The workspace is located under \workspace\ directory of Eclipse installation directory
For example c:\eclipse\workspace
The workspace contains user defined data – projects and resources such as folders and files
By default, Eclipse uses a Workspace to store your projects, their resources and other information. Eclipse’s default workspace is directory in your Eclipse installation directory called \workspace. You can change the default locations with arguments to the eclipse.exe – see next slide.

25. Running Different Workspace …
It is possible to run workspace other than default
-data argument must be used with eclipse.exe
Workspace location must be specified
Useful for grouping project specific data
Multiple workspaces can run at the same time
For creating a new workspace, its location needs to be specified as an argument to eclipse.exe. The remainder of the work (meta data information) is done by the Eclipse.

26. … Running Different Workspace
Customize your working directory by creating a shortcut identifying the eclipse.exe and the working directory
To make starting Eclipse easy, create a shortcut (Windows only) specifying the location of the eclipse.exe and the default directory. Place the shortcut on the desktop for easy access.

27. Module Summary In this module you have learned:
What Eclipse is, its background and components
How Eclipse is used
How to download, install and run Eclipse
How to create and run multiple workspaces with Eclipse

28. Module Road Map 3. Building and Running Java Classes Overview
Installing and Running
3. Building and Running Java Classes
Developing Java applications
Projects, packages, classes
Browsing Java code
Searching Java code
Organizing Java code
Using Code Assist
Running Java applications
Scrapbook
4. Debugging
Let’s begin by using Eclipse to build your Java project. We will be discussing Eclipse’s Java and Java Browsing perspectives, as well as how to build and run Java applications with Eclipse.

29. Java Development Tooling - JDT
Eclipse’s Java Development Environment is often referred to as JDT – Java Development Tooling
Using the JDT you can do following with the Java programs:
Write
Compile
Test
Debug
Java Development Tooling is the set of Eclipse plug-ins that allow you to write Java programs. It is fully featured Integrated Development Environment.

30. Perspectives When developing Java code commonly used perspectives are:
Java Perspective
Designed for working with Java projects
Java Browsing Perspective
Designed for browsing structure of Java projects
Java Type Hierarchy Perspective
Designed for exploring type hierarchy
Debug Perspective
Designed for debugging Java programs
In this module we will talk about Java Perspective, Java Browsing Perspective and Java Type Hierarchy Perspective.

31. Java Perspective Contains: Editor area Package Explorer View
Hierarchy View
Outline View
Tasks View
The Java Perspective is where you spend most of your time when developing Java code.
Package Explorer View shows the Java element hierarchy of the Java projects in the Workbench.
Hierarchy View shows the hierarchy of a type.
Outline View displays an outline of a structured file that is currently open in the editor area, and lists structural elements. For example an outline view for a Java class displays all fields and methods for that class. The contents of the outline view are editor-specific.

32. Java Browsing Perspective
Contains:
Editor area
Projects View
Packages View
Types View
Members View
Projects View shows all projects available in the Workbench.
Packages View shows all packages available for project selected in the Projects View.
Types View shows all Types (classes and interfaces) from the package selected in the Package View.
Members View shows all fields and methods for the type selected in the Types View.

33. Java Type Hierarchy Perspective
Contains editor area and Hierarchy View
The Java Type Hierarchy Perspective is not used as much as the other two Java perspective.

34. New Project Preferences
You can set global preferences for a project
Select Window -> Preferences to get Preferences View
Good idea to separate your Java files into source and compiled directories (src and bin)
This action only needs to be done once
Done for all subsequent projects

35. Creating Java Project
Project used to organize resources (source, class, icons) for a project
To create Java project:
Select File  New Project… from the menu
The New Project wizard comes up
Select Java  Java Project
Click Next

36. New Project Wizard
Specify Project Name
Click Next

37. Java Settings Specify Java settings Click Finish
Output folder (where compiled files will be stored)
External jar files project depends on
Classes from other projects that are referenced in the project
Click Finish
The Java Settings for a project is very important as you use it to set Java build path. You don’t have to set the build path at the project creation time, as at any given time you can go back to the build path through Properties for the project.

38. Project Properties You can change the Java build path at any time
Choose Properties from the context menu on the project

39. Creating Packages Package contains Java class files
To create a package for a project:
Select the project
Choose New  Package from the context menu
Specify package name
Click Finish

40. Creating Classes To create a class in a package: Select the package
Choose New  Class from the context menu
The Class wizard comes up
Specify class details
Click Finish
If you specify wrong details for the class in the wizard, you can always change them later directly in the editor. When creating class Eclipse gives you an option of specifying if you would like to create a main() method for the class, or create constructors from the superclass. In the wizard you specify superclass for the class as well as modifiers (abstract, final, etc.)

41. Using Code Assist
When activated, code assist opens a list of available code completions
Code Assist activates by Crtl+Space
Activates automatically when a message needs to be sent to an object (after the dot is typed)
Code Assist can also be activated from the Edit menu by choosing Edit -> Content Assist. It could be customized in the Preferences window.

42. Using Quick Fix Useful if Java compiler shows errors
Gives options for fixing the errors
Activated through Edit  Quick Fix menu option
Error indication
Quick Fix can be used for fixing the compiling errors. In the above example type File is used for declaring field file. The error is indicated by a red rectangle on the right of the line, by red underlined name of the missing type, and by error icon on the left from the line.
Quick Fix can also be activated by click on the bulb icon in the editor.

43. Searching for Java Classes
When developing Java application a good search mechanism is very important
You often search for class, method declarations, and references
It is important to be able to find things quickly
Eclipse Java Search mechanism is very extensive
It allows you to search for:
Types, methods, constructors, packages, and fields
Declarations, Implementers, References
In the scope of Workspace, Working Set, or Selected Resources

44. Organizing Java Code
Eclipse comes with extensive support for organizing and refactoring Java code
It is possible to:
Generate getters and setters for the fields
Organize missing import statements
Move fields, methods, classes
Rename methods, classes, packages

45. Generating Getters and Setters
Available for creating get and set methods on the fields
It supports encapsulation
Activated by choosing Source  Generate Getter and Setter from the editor’s context menu
Generation of getters and setters for instance variables support one of the first object-oriented principals: encapsulation. Encapsulation is that no internal state of an object should be accessed directly. This means that an internal object state should be represented through private field, and a method for accessing field should be provided. Object’s internal state is than accessed by sending a message that represents that method to object. Method for accessing object’s internal state is known as getter (get method) and method for setting object’s internal state is known as setter (set method). Usually each private field has corresponding getter/setter methods.

46. Refactoring
Available from the Refactor context menu option in the editor
Helps with refactoring Java code
Allows for:
Renaming
Methods, fields, packages, projects, parameters, or local variables
Changing of method signature
Pull up a field or method (into superclass)
Push down a field or method (into subclass)
Encapsulate field (generate getter and setter)
Extract method, local variable, or constant from an expression
Refactoring is commonly used in programming and its goal is to improve the code by not affecting its functionality.
You can preview all of the changes resulting from a refactoring action before you choose to actually do the changes.
During the preview you will be notified of potential problems and will be presented with a list of the changes the refactoring action will perform.

47. Running Java Classes To Run Java application
Choose Run  Run… from the menu
When you open Run Dialog under Java Application are listed all classes that contain main() method, i.e. that can be run. If your class is not listed here, click on New to add all classes with main() method to this list.
In the Run Dialog you can set some options before starting the Java application. You can set program and VM arguments on the Arguments page. You can also set Java Runtime Environment on the JRE page, and you can change the classpath on the Classpath page.

48. Console View Represents standard Java console
Opens by default when standard Java output is used
Can also be open from Window  Show View menu
System.out.println("Hello World");

49. Scrapbook… Allows for writing and executing of Java code
Very useful for quick test of Java code that you write
The Java code in the Scrapbook can be:
Displayed as a string when evaluated
Inspected when evaluated
Opens an Inspector view where you can see returning object from evaluation and all containing fields
Executed

50. …Scrapbook…
It is created by selecting a project and choosing New  Scrapbook Page from the Package Explorer’s context menu and then entering the name of the page
Your scrapbook page will become a resource in your project

51. … Scrapbook… To open the scrapbook page just click on the resource
It opens up like a Java source file editor
Type Java code and select the context menu to Display or Inspect

52. …Scrapbook Class names must be fully qualified in what you type
Set imports to make life easier
Think of your scrapbook as a page that Eclipse will take the source you type, wrap it in a class with your source in the main menu, then compile and execute

53. Summary You have learned: How to create projects, packages and classes
How to browse Java code and search for Java code
How to use coding assistance
How to organize Java code
How to run Java code
How to use the Scrapbook

54. Module Road Map Eclipse Debugging Overview Installing and Running
Building and Running Java Classes
Eclipse Debugging
In this module, you will learn about Eclipse’s debugging facility

55. Module Road Map Eclipse Debugging Debug perspective Debug session
Breakpoint
Debug views
Breakpoint types
Evaluating and displaying expressions
In particular we will look at the Debug Perspective and its components, breakpoints, and facilities commonly used when debugging.

56. Debugging in Eclipse The Java Debugger
Part of Eclipse Java Development Tools (JDT)
More than System.out.printn(̎̎̎̎error̎̎̎̎)
Detects errors as code executes
Correct errors as code executes
Actions you can perform debugging include:
Control Execution
Set simple breakpoints
Set conditional breakpoints
Review and change variable values
Hot code replace (feature new to JRE 1.4)

57. Threads and Monitor View
Debug Perspective
Threads and Monitor View
Variable View
Editor View
Debug perspective is design to help debugging the code. It contains views that are specific for debugging. Perspective opens automatically when a breakpoint is hit during the execution of the Java application. However you need to run Java application in a debug mode, otherwise the execution will not stop at the breakpoint, and the breakpoint will be ignored.
Console View
Outline View
Tasks View

58. Simple Breakpoint Breakpoint Setting a breakpoint
Stops the execution of a program at the point
Thread suspends at the location where the breakpoint is set
Setting a breakpoint
CTRL+Shift+B at current point in editor line
Double click in editor’s marker bar at current line
Breakpoint can be set by:
Double-click on the left bar beside the line in the editor where you want to add the breakpoint
Choosing Add Breakpoint from the context menu on the bar in the editor

59. Starting a Debugging Session
Select Java class containing the following:
main() method
Resulting execution will pass breakpoint
Select Run  Debug As…  Java Application
Or Select Debug As…  Java Application from the debug menu
Debugging session usually starts on a Java application, i.e. class containing the main() method. The debugging session can also start if you execute Java code from the Scrapbook and a breakpoint is encountered during the execution.

60. Debug Session Execution suspends prior to the line with a breakpoint
You can set multiple breakpoints

61. Deleting Breakpoints Double click on the breakpoint in the editor
Another way to remove the breakpoint is by choosing Remove Breakpoint from the context menu on the breakpoint.

62. Control Execution From Breakpoint…
Step Into or F5:
For methods, execute method and suspend on first statement in the method
For assignments, similar to Step Over
For conditionals, similar to Step Over
Step Over or F6
Execute next statement
Step Return or F7
Resume execution to the end of the method on the next line after it was invoked
Control Execution toolbar buttons are used for controlling the debugging session.

63. …Control Execution From Breakpoint
Resume or F8
Continue execution until program ends or another breakpoint is reached
Terminate
Stops the current execution thread

64. Variables and Fields To see the values bound to fields:
Use Variables View
Select variable in editor and select Inspect
Select variable in editor and select Display

65. Code Debugging in this Module
public class Debug {
private int something = 0;
private Vector list = new Vector();
public void firstMethod(){
thirdMethod(something);
something = something + 1; }
public void secondMethod(){
something = something + 2;
public void thirdMethod(int value){
something = something + value;
public static void main(String[] args) {
Debug debug = new Debug();
debug.firstMethod();
debug.secondMethod();}

66. Variables View Shows all fields of instance where breakpoint occurred
Select this to see all fields
Select any field to see value
If field is bound to an object, you can select Inspect from the menu to view its fields and values

67. Changing Field Values To change field value:
Select field in Variables view
Select Change Variable Value from the menu
Enter new value into Set Variable Value window
Click OK

68. Display View
Displays the result of evaluating any expression in the current context
Opens by:
Selecting a field in the editor or Variables View and choosing Display
Clicking on the Display tab

69. Expressions View Remembers all objects you have inspected
Displays the fields of the object
You can see the values of the fields
You can Inspect the fields
Opens when:
You Inspect an object
You click on the Expressions tab
Expression view is used with the Inspector. You can also invoke the view from a Scrapbook by selecting the Java code and choosing Inspect from the context menu.

70. Breakpoint View Lists all available breakpoints
Can be used for manipulating breakpoints (through the views menu):
Enabling
Disabling
Removing
Also displays breakpoints properties
Accessed like other debugging views
Breakpoint View can be open by click on the Breakpoints tab in the Debugging Perspective.
Breakpoints can be manipulated in the Breakpoint View, meaning that you can remove, enable, or disable breakpoints. Double-click on the breakpoint in the view opens up an editor on the code where the breakpoint is set, and selects the line with the breakpoint.
Breakpoints properties are viewed by choosing Properties from the context menu on a breakpoint.
It is possible to set conditional breakpoints from the properties view. These breakpoints stop the execution only if the condition evaluates to true. To specify condition select the Enable Condition in the properties window and specify the condition.

71. Debug View
Shows:
Active threads
Current stack frame when execution has stopped
Previous stack frames
Method and variables are shown in the editor for the selected frame
Update in the editor updates the source
When you debug, an editor on code that you debug is available in the perspective. When the execution stops at the break point editor shows (highlights) the line where the breakpoint is. Using debugging controls results in editor showing different methods, variables, etc. You can change the code in the editor directly, save the change, and continue with the debugging.

72. Breakpoint Types
Breakpoints can be set for the following Java entities:
Line (simple breakpoint)
Method
Field (watchpoint)
Java Exception
Each breakpoint is set a different way and has different properties
Watchpoint suspends execution when a particular field is about to be accessed.

73. Method Breakpoints To set method breakpoint:
Select method in the Outline View
From context menu select Add/Remove Method Breakpoint
To set breakpoint’s properties:
Select breakpoint in editor
Select Breakpoint Properties.. from context menu
Set properties as desired
Entry, exit, enable hit count
Execution suspends on entry/exit into method
You cannot specify condition for method breakpoints, i.e. methods breakpoints cannot be conditional.

74. Field Breakpoints Also known as watchpoint To set the watchpoint:
Select field in the Outline View
From context menu select Add/Remove Watchpoint
To set watchpoint’s properties:
Select breakpoint in editor
Select Breakpoint Properties.. from context menu
Set properties as desired
Access/modification, enable
Execution suspended on access/modification of field
You cannot specify condition for field breakpoints, i.e. field breakpoints cannot be conditional.

75. Java Exception Breakpoint
To Add Java Exception Point:
Select Add Java Exception Point from menu
Enter exception type
Specify what triggers a breakpoint:
Caught exception
Uncaught exception
Both

76. How To Debug Here are simple steps for debugging in Eclipse:
Set your breakpoints
Hit a breakpoint during execution
Walk/step through code to other breakpoints
Follow along in editor
Inspect/Display interesting fields
Watch the Console for things to happen
Debugging is an important facility of any development environment. Eclipse debugger contains facilities that help you in debugging the code. You will find that inspecting objects is probably most commonly used activity during the debugging. Watch what happens during the debugging, i.e. watch for field, variables values.

77. Summary You have learned: The views in the Debug Perspective
Typical debug session
How to use the Inspector
About the different types of breakpoints
How to set breakpoints
How step around your code doing debugging