Making a rich client application in eclipse is quite similar to plug-in development work, with a little different approach. Here it is discussed in steps.

1. Go to“ File” – > “ New ” – > “ Project ” > “ Plug-in Development ” > “ Plug-in Project ”.

1. Give name to Project and move next.

1. Plug-in Content options will appear. At this time instead of moving with default options, in Rich Client Application section, select “ Yes ” radio button.

1. Available templates will appear in next option. Here select “ HelloRCP ” Template, to keep the things simple.

1. Click “ Next” to finalise and then “ Finish ”.

1. OverView and Outline panes will appear, displaying information of the application.

1. Now click on “ Launch an Eclipse application ” in Overview Pane to see the application working.

1. Finally we will define product configuration file and export our application.
2. Go to “ File ” – > “ New ” – > “ Other ” – > “ Product Configuration ”.

1. give some name to file, and select application. “ Finish ” to exit.
2. Give Product ID, Application and Product name in their respective fields.

1. From configuration tab, add your plug-in and “ required plug-ins ” for our application.
2. From overview tab, select “ Eclipse Product Export wizard ”.

1. Standalone rich client application has been exported into archive file.

The application made is platform independent and will behave as a native application in any Operating System.

1. Listed below is a Javadoc comment style used to generate a Javadoc. Use following comment style to generate a Javadoc.



/****This is a sample Java Comment**
 
*/

Above is a snapshot of Javadoc comment in IDE.

2. Click on projects link and choose ” Generate Javadoc ” option.



3. Now a window will be opened where you can select Java Projects or their underlying resources for which JavaDoc needs to be generated. Several other options are also there where user can select any of them as per the need.Here user can select whether to generate JavaDoc for public/private API’s etc.



4. Now IDE asks for other features as well for the generation of Javadoc. A Java programmer should be familiar with these options.



5. You can also save settings as ant script so that you can use the script to generate javadoc in future.



6. Click “Finish” Javadoc will be generated. If you select option of opening index file in browser then after generation of Javadoc you will find ” index.htm ” of Javadoc in your default Web Browser. On console you can see progress of JavaDoc Generation.

1. Click on the projects. You can see a lot of options regarding building projects in Java.
   
   • Build All : It builds all the projects available in the workspace to output directory defined for each project
   • Build Working Set : It builds projects in some working set to their output directories.
   • Build Automatically : It builds all the projects automatically, In short it builds as soon as a java resource is modified it builds that part of code and show errors/warning at problems tab. If no error is found then put the class file to the output directory.
2. Now click on ” Build Working Set ” It will ask user to choose working set .



3. In the next window you can either choose set of projects already made or you can make a new working set of projects.



4. click on ” New ” as we are making a new working set.



5. Select Java and press “Next”. It will ask you to include projects from workspace to the working set we are going to create.



6. Select the projects you want to add in the working set and click “Finish”.



7. You can see the results in problems window. If any Java unit have problems in compilation then It will be shown, so that the user can correct them and rebuild the working set again.

From a Java Programmer there are a varieties of tools but if you are using an editor then it becomes quite easy for you to debug the program.

Here are the steps to be followed to debug a Java program using Eclipse.

1. The very first step in debugging is to load your application and open the “java” file that you wish to debug. Do not forget to switch to Debug perspective.



2. Now a window will be appeared where you can find several options for debugging the project. It is better to describe about the options available here. Using Eclipse you can debug not even a Java application but also a Remote Java Application (by specifying the remote port number), Junit Test Case, SWT Application etc. After supplying the arguments. Click the “Debug” button. Debugger will connect to your java application under debugger perspective.



3. Now you can enable or disable debug points in the application by just making a double click on the line where you want to stop execution of the program.



4. Now you can enable or disable debug points in the application by just making a double click on the line where you want to stop execution of the program.



5. Now use can use either keys F5-F8 or bar shown below debug window for debugging the application.
   Here is the use of each button for debug purpose.
   • Step Into: To go inside a Method.
   • Step Over: To bypass the next line of code.
   • Step Return : To come out of the current execution of method to original from where you stepped in.
   • Resume: to resume from the current breakpoint.

public static void main(String[] args) {

which means that it takes a string array as the input argument. How can those be passed while running as a standalone class with in the Eclipse IDE? How can we use those input parameters with in a program? These are the some of the questions discussed here.

To execute a class having the main method with arguments follow the steps below.

1. Click from menu bar.
2. “ Run ” – > “ Run ” and now select “ Arguments tab ”. Text area against “ Program Arguments ” is available to enter arguments. You can add any number of arguments but each parameter should be separated by a space. Space is the delimiter here.

For instance, if we give following text in the “ Program Arguments ” window,

hello world, hi hallo

then we will have 4 arguments namely.

1. arg 1: hello.
2. arg 2: world.
3. arg 3: hi.
4. arg 4: hallo.

Many people think that comma (,) or semi colon (;) is delimiter but it just a misconception. Delimiter is “ space ”.

Consider the following program arguments:

In the main method, we will print the size of the input array and also will print each argument.

public class MainClass {
  public static void main(String[] args) {
    System.out.println("No. of argumetns are: " + args.length);
       for(int i= 0;i < args.length;i++)
          System.out.println("Argument " + i + " is : " + args[i]);
 
    }
 
}
 
Output:
 
No. of argumetns are: 4
 
Argument 0 is : hello
 
Argument 1 is : world,
 
Argument 2 is : football
 
Argument 3 is : match

We can cast and use the input parameters incase you want something other than String as shown below.

public class MainClass {
   public static void main(String[] args) {
          double dd = new Double(args[0]).doubleValue();
    }
 }

First step is installing the plugin. As with other Eclipse plugin, its really very easy to install and configure AnyEdit.

1. Download the plugin from here.
2. Unzip the file and copy ” de.loskutov.anyedit.AnyEditTools_1.8.0.jar ” to ” Plugins ” folder under Eclipse.
3. Open Eclispe and everything is read to use.

Suppose we have following Test class:

public class Test {
public static void main(String[] args) {
 
      for(int i=0;i< 10;i++)
 
      {
 
    	  System.out.println("Printing HELLO WORLD. Count: " +i );
 
      }
 
    }
 
}

And we want to save the generated output to a text file from Eclipse IDE. we used to copy the output from ‘Console window’ and will create a new text file from file system and then will paste the output text there. AnyEdit adds all this into Eclipse IDE. You just have to right click in the ‘Console window’ of Eclipse and click ‘Save to File’.

Sometimes it is useful for the developer to see the white spaces in the source code. AnyEdit provides this option in the toolbar. Just click ‘Show white spaces’ icon from toolbar and you can see the white spaces in the development environment.

You can change the case of text by: ” highlighting text ” – > ” right click “, choose Convert – > ” To upper case/To lower case/Invert case/Capitalize “.

AnyEdit also adds a search dialog box which gives some more flexibility to the search feature.

‘Show Source of Selected Element Only’ is also a very useful feature. Consider that you are working in a method of a class with many methods. Then you will be viewing all the code, even that code which you are not editing. This can confuse you. Using ‘Show Source of Selected Element Only’ will hide all the code except that particular method on which you are working.

AnyEdit has a lot of simple but useful options that eases the programming in Eclipse.

Abstract Windows Toolkit (AWT) does not have fancy looks as compared to Swing but its advantage is that it can run at any place where Java runtime environment is installed. It is very stable technology.

Swing provides GUIs that have fancy and sophisticated look and feel. It is included in the Java Foundation Classes (JFC). These are said to be slow as the controls are made by the Java itself.

Standard Widget Toolkit (SWT) is an open source Java GUI toolkit comprised of a widget set and a graphics library. It provides GUIs having look and feel very similar to the native desktop applications. This is supposed to be faster as the controls are built by the native dlls.

Jigloo is an Eclipse plugin which can be used to design AWT, Swing and SWT GUIs quikly and efficiently. It is free for non commercial use.

First download the plug-in from here. Unzip it and move the folder “ plugins\com.cloudgarden.jigloo_3.9.5 ” to the plugins folder under Eclipse directory and move “ featues\com.cloudgarden.jigloo_3.9.5 ” to the features folder under Eclipse directory. Now simple open the Eclipse. Jigloo GUI plugin is read to use.

Listed below are the steps to create a simple Swing Jframe using Jigloo.

1. First create a project named “ GUI test ”.
2. Now right click the project and create a new Swing Jframe (“ New ” – > “ Other ” > “ GUI Forms ” – > “ Swing ” – > “ Jframe ”).



3. Change the title of the JFrame to “ Test Frame ” by typing the text in the “ Title ” property in GUI Properties window.



4. After creating the JFrame, you will see the frame, code and the setting windows. In the design windows, you will be shown the graphical preview of your frame. It will have different menus and tabs. Tabs contain different controls that we can use according to our requirements.



5. In our example, we need a container on JFrame. So we will drop JPanel control from Containers tab on to our frame.



6. Now select and drop JTextField control from Components tab on to the JPanel and name it as “ jtxtfld ”.



7. Select and drop JButton control from Components tab on to the JPanel and name it as “ jbut ”
   
   Our GUI looks like thisNow we have to add a functionality that when a user presses the button, the text in the textfield is printed on the console. To achieve this, we to get the mouseClicked event of the button.
8. Click JButton (jbut) and then go to Event window. Event window will have all the events available for the JButton. Select “ MouseListner ” – > “ mouseClicked ” event and change its value from to inline. Doing so, code for the event will be generated. Now we just have to go to the code window and locate the mouseCliced event code and write the print statement there.

public void mouseClicked(MouseEvent evt) {
 
System.out.println(jtxtfld.getText());
 
}

Now try running the Java Class.

There are many XML plug-ins available for the XML manipulations, but the most popular one is “ XMLBuddy ”. Its a free-ware plug-in and allows XML editing features in Eclipse environment.

First download the plug-in from http://www.xmlbuddy.com. Unzip it and move the folder named “ com.objfac.xmleditor_2.0.9 ” to the plugins folder under Eclipse directory. Now simple open the Eclipse. XML plug-in is read to use.

Now you can see a new menu called “ XML ” added to the menu bar.

Two new icons are also added for creating new XML and DTD files.

Create a new XML file by clicking the “ New XML File ” icon and name it. Type the contents and save it. To validate it, click from menu bar “ XML ” – >“ Validate ”.

Errors will be marked as red and you can correct those.

You can see the outline of your XML document in the outline window.

To change the preferences, click from menu bar “ Window ” – >“ Preferences ” – > “ XMLBuddy ”

Form here, you can change the settings as you like. For example we want to change the color of elements start and end tags..

By default, element’s start and end tags are BLUE and we want to make them RED. This can easily be done from XMLBuddy Preferences window (“ Preferences ” – > “ XMLBuddy ” – >“ XML ” - > “ Colors ”).

Now our xml file looks like this:

<catalog>
	<cd>
 
		<artist>Bob Dylan</artist>
		<country>USA</country>
		<company>Columbia</company>
<price>10.90</price>
		<year>1985</year>
	</cd>
	<cd>
 
		<artist>Bonnie Tylor</artist>
		<country>UK</country>
		<company>CBS Records</company>
<price>9.90</price>
		<year>1988</year>
	</cd>
</catalog>

Using XMLBuddy definitely saves time if you are working with XML files.

As stated above Eclipse can be used as a Plugin Development Environment (PDE) which is a set of tools that help the developers in developing, testing, debugging, building, and deploying Eclipse plugins.

The plugin Development Environment (PDE) has its Wizard template to create plugins. The plugin,to be created will associate Eclipse with the file extension “.myext”. The plugin’s wizard will enable the user to create files with this extension, and when the user double-clicks on those files, they’ll appear in the plugin’s editor.

1. Select “ File ” – >“ New ” – > “ Project ”. Then select “ Plugin Project ”. Wizard will start asking for information.



2. Give plugin project name.



3. Providing content provider is important for plugins, to verify potentially safe providers.



4. Next we will select the template of Multipage Editor plugin.



5. Next provide the file extension you want to be used, in this case “ myext”.



6. Next window will ask the option, wizard of this plugin will ask to create file. Here you have to specify file extension and initial file name.



7. Finish to exit. Now, to test our plugin go to context menu of plugin project and select “ Run as ” – > “ Eclipse Application ”.



8. A new instance of eclipse will get started. In this instance make an empty project ‘abc’ in this case. Then move to File > “ New ” – > “ Other ” – > “ Sample Wizard ” – > “ Multi-page Editor File ”.

Your plugin has generated a file with your customized extension.

Creating plugins for Eclipse using PDE is very useful in situations involving project development in teams. This area is wide open and lot of work is being done.

JUnit provides close relationship between testing and development. As developers write the code, they use the JUnit test runners to verify how much it deviates from the intended goal. Normally it is a standard practice that the code developers themselves write unit tests for their code.

First step is to put “ junit.jar ” on the build Path. Go to project properties and click “ Java Build Path ”. In the Libraries tab click “ Add External JARs ” and then browse to “ junit.jar ”.

Suppose we want to test method called “ getSmallest() ” in class “ Test.MainClass ”. This method takes an integer array as input argument and returns smallest integer from that array. We will write “ TestCase ” to test this using Junit.

package Test;
 
import java.util.*
public class MainClass {
 
public static void main(String[] args) {
 
 }
 
public static int getSmallest(int arr[]){
 
 	Arrays.sort(arr);
 
 	return arr[0];
 
 }
 
}

Right click “ project name ” and click “ New ” – > “ Junit Test Case ”. New JUnit Test Case window will open. Name the test case and select class for which you are writing the test case. In my case, I selected Test.MainClass. Click Next.

Now we have to select the methods from the chosen class for which test stubs will be generated. In my case, I selected “ getSmallst(int[]) ”. “ Click Finish ”. Test stubs for the method is generated but we have to write a little code to test it.

Review the code below:

package Test;
 
import junit.framework.TestCase;
 
public class test_case_getSmallest extends TestCase {
 
public test_case_getSmallest(String arg0) {
 
 	super(arg0);
 
 }
 
protected void setUp() throws Exception {
 
 	super.setUp();
 
 }
 
protected void tearDown() throws Exception {
 
 	super.tearDown();
 
 }
 
public void testGetSmallest() {
 
MainClass o = new MainClass();
 
 	int[] myarray ={100,200,30};
 
int val;
 
 	if((val = o.getSmallest(myarray)) != 30)
 
 	{
 
 		System.out.println("Shortest value returned is : " + val);
 
 		fail("Not right result.");
 
 	}
 
}
 
}

To run it, right click the test case (test_case_getSmallest.java) and click “ Run As ” – > “ JUnit Test ”. Test will run and the results will be shown. In my example, I got the following results.

Now to see failures. We changed the “ testGetSmallest() ” code as

public void testGetSmallest() {
 
MainClass o = new MainClass();
 
 	int[] myarray ={100,200,30};
 
int val;
 
 	if((val = o.getSmallest(myarray)) != 100)
 
 	{
 
 		System.out.println("Shortest value returned is : " + val);
 
 		fail("Not yet implemented");
 
 	}
 
}

Output I was shown is:

In this example,we are just testing a method using a simple test case. We can test more than one methods using same test case as well. For instance, we could have more than one methods in our class “ MainClass ” and then more than one test stubs in our test case “ test_case_getSmallest() ”.