• Chrome > Settings
• Tick Developer Mode
• Click ‘Load unpacked extension’
• Select the folder you extracted the files to.
• Enjoy

Preparing Eclipse

Creating your first Java project

There are numerous ways to create a simple java project.

Click File->New->Project…Then select ‘Java Project’. You can also accomplish this by right-clicking on Project Explorer on the left side of Eclipse, and selecting New->Project… and select Java Project.

Then click Next. Next I will enter a Project Name, ‘Lab1′. Select your JRE environment. Click Next. Eclipse will create a folder for your project with a subfolder ‘src’. Then click Finish.

Browsing Java elements using the Package Explorer.

The package explorer displays your java files organized in their packages. Eclipse will create a default package when creating a java class without a package name. You can expand the package names to display the files within by clicking on the ‘+’ on the left side of package names. Click on ‘-‘ to collapse expanded packages.

Editing java elements

To edit a java element that contain text like java classes or properties files, doubleclick the filename, a new window with content of the file opens in the editor in center. You can edit the file and save to make changes.

Creating a Java class

Now lets create a java class to make a small program. We will make a class called Calculator.java that contains a Add() method. Right click ‘src’ folder on package explorer and click New->Class. You can achive the same result by selecting File->New->Class too. I will class this class ‘Calculator’. Lets give it a package name ‘a24.labs.lab1′. Make sure ‘public static void main…’ is unchecked, I will create another class to create the main method which will use the Calculator class.

Click Finish. I will put a method that adds two numbers.

public int add(int a, int b){
                return a + b;
}

Renaming Java elements

To rename a file, in Package manager, right click ‘Calculator.java’, select Refactor->Rename. Rename the file to ‘Math’. By default Eclipse will update all the references that points to Calculator to the new Math class name. Notice in the source code, ‘public class Calculator’ is changed to ‘public class Math{‘. Eclipses take care of changing the class name within the java file.

Moving and copying Java elements

Files can be moved between packages by simply dragging them. It can also be done by right clicking the file, selecting Refactor->Move. Lets create a new package called ‘ecl500.a24.lab1′ and move Math.java file to that package. To create a new package, right click src folder, New->Package. Then drag the ‘Math.java’ from ‘a24.labs.lab1′ package to ‘ecl500.a24.lab1′. To create a copy of the java file. Right click on the file and select Copy. Then on destination location, say a24.labs.lab1, rightclick and select paste. Delete the old ‘a24.labs.lab1′ package along with its content by rightclick and selecting Delete.

Navigate to a Java element’s declaration

Eclipse’s right click context menu has several functions that are very useful. One of the functions is ‘open declaration’. Open declaration opens the declaration of a type.

To test this, lets use the Math class to perform some calculation. Create a new class called ‘Program.java’ in ecl500.a24.lab1 package. Right click on the package name and select New->Class. Call this class ‘Program’. Make sure to check ‘public static void main..’ option. Now right click on word Math and rightclick, Open declaration. Eclipse automatically opens the Math.java and highlights the class declaration. You can also accomplish this by selecting Navigate->Open Declaration

Viewing the type Hierarchy

You can right click on any java file and rightclick select Open type hierarchy to see the type hierarchy of the class file. In the image, Our Math class is a subclass of Object class.You can also accomplish this by selecting Navigate->Open Type Hierarchy.

Searching the workbench

Eclipse has a strong search feature. Open Search dialog by selecting Search->Search. There are 3 tabs for searching ‘Java Search’, ‘JavaScript Search’ and ‘Plug-in Search’.

To do a granular seach you can use wildcards like * and ?. You can search fo ‘Type’, ‘Method’, ‘Package’ etc. If you search for Math or M* or M???, you should be able to see Math resulted from all files. To search within a file, press Control+F in the text editor.

Running your programs

There are several ways to get your java program run. The easiest way is to click on the Run icon on toolbar. This can also be accomplish by selecting Run->Run or rightclick on file and Run->Run. You can also use keyboard shortcut Control+F11 to run the program. The output is displayed on Console view.

If your java application uses GUI, the output will be on a new window as a separate application. If you want configure how your java application runs, then you can create a run configuration.

For example if your program need to take some arguments when run, or if your program must include some other library like JDBC connector package, you can create a run configuration that sets these up every time your program is run.

Lets create a run configuration called ‘Program’ by clicking New icon. Let me change the JRE to my alternate JRE. Click apply to save and Run to run the program. Now to run this program with same configuration, you can quickly select the Program name on run icon.

Debugging your programs

To debug a program we put breakpoints in various lines of code and the program pauses the execution on that line of code. Then you can analyse values of variables or execute the rest of the program line by line. To debug in Eclipse, put a break point on a line in Math.java where the a+b is calculated. Now right click on the vertical grey bar on the left of editor and select toggle breakpoint. You can also do this by doubleclicking on the bar. Do the same process to remove a breakpoint.

Now click on the debug iocn on toolbar. Eclipse gives you option to switch to Debug perspective. Click Yes. The program executes and pauses on the line where we put the breakpoint.

If you hover over any variable, you can see the value of the variable. From here, you can execute the rest of the program step by step. Click on ‘Step into’ button several times. You will see the program moves forward line by line. To execute a full method without going into the method, you can press the ‘Step Over’ button.

Click stop to stop debugging and click on ‘Java’ button on perspective view on top right corner to return to normal view. Remove the breakpoint by double clicking on it.

Evaluating expressions

Put a breakpoint on the last line of Program class and press debug. The program pauses on last last. It has not executed this line yet. Now select the method call myMath.add(100,200) then rightclick and select Display. The value of result return value of this method 300 is shown on display popup. Press control+Shift+D to move this value to Display view. Now in display view, we can see what method was executed and what result was returned with its type information as well.

Evaluating expressions is useful during debugging a program. Stop the debugging and go to Java perspective view.

Evaluating snippets

Scrapbook is a file where you can test small pieces of expressions in your program. It is useful for checking values of systems value. like value of PI. Create a new Scrapbook Page, name it MyScrapbook and click Finish. A new file MyScrapbook.jpage appears in your package explorer. Open MyScrapbook.jpage

Type Math.PI , select the Math.PI, rightclick and select Display. To check 100+200 in our method call really should be 300. Type 100+200 in scrapbook, select the line, rightclick and select Display. You will see the value 300 which confirms your add method is working fine.

You can write some snippets and quickly check the result without creating a class file.

Using the Java browsing perspective

Java browsing perspective shows a drill down browsable view of your Project, Packages, Types, and Member methods. It displays the content of the method in the bottom editor. It is a built in perspective created by Eclipse. The look and feel is like a file browser. Some people may prefer to use this perspective for coding. The choice is yours.

Writing and running JUnit tests

With JUnit test, we can create programs using test driven software development approach. Test cases are conditions that testers create. The developer has to develop program that passes these test cases. When developer creates program which passes the test cases one by one, gradually the program is fully developed.

Lets create a subtract method to our program using JUnit test. Lets create a test for subtract method. We know (using a calculator) 300-100 = 200 for a subtract to be working good.

In Math.java, create an empty method for subtract.

public int subtract(int a, int b){
  //no code yet. waiting for test cases. just return 0.
  return 0;
}

Now lets create the Junit test. Select File->New->JUnit Test Case. Name this MathTest, click Next, select the subtract method, and click Finish. Click OK to add JUnit in build path.

Now select Run->Run as->JUnit Test. A new view is added to the perspective called JUnit. Since the subtract method is not implemented the test fails.

Lets create the test.

public class MathTest {
        @Test
        public void testSubtract() {
                Math math = new Math();
                assertEquals(100, math.subtract(300, 200));
        }
}

Now in Math.java lets write a wrong code for subtraction to test the case. we will return a*b instead of a-b. This should fail the test we wrote. Run the test by clicking on the Rerun test button on JUnit view. As expected the test fails again.

Now correct the subtract method code to

return a-b;

then rerun the test.

Click OK if asked to save and launch.

The test passes and the red bar changes to green. Failure is set to 0. In this way, we can use the JUnit test in Eclipse.

class ProgramConfiguration{
    public ProgramConfiguraiton(){
        //default constructor code
    }
}

class ProgramConfiguration{
    private ProgramConfiguration(){
        //default private constructor code
    }
}

class ProgramConfiguration{
    private static ProgramConfiguration _configObject;
    private ProgramConfiguration(){
        //default private constructor code
    }
    public getInstance(){
        /*
        if an instance exist return that instance otherwise
        call the constructor to create an instance and return it.
        */
        if(_configObject == null){
            _configObject = ProgramConfiguration();
        }
    return _configObject;
    }
}

public static void main(String[] args){
    /*
    no access to default constructor. so if you did
    ProgramConfiguration pc = new ProgramConfiguration();
    you will get compilation error.
    */
    ProgramConfiguration pc = ProgramConfiguration.getInstance();
    ProgramConfiguration newpc = ProgramConfiguration.getInstance();
    /*
    in the above code pc and newpc both point to the same static object. when
    getinstance() is called for the second time, it finds that _configObject is not null
    anymore, so it doesn't call the constructor to create any new instance.
    */
}

1. When working on a large software, numerous instances of classes are created continuously at the runtime. The programmer cannot predict what the user is going to do. So at any given time, the programmer doesn’t know what object is create. For example, To create a new document, the user might click new text document or new spreadsheet document. There would several possibilities about what the user is going to do. So, a factory class is assigned to do all these repetitive work of creating a new instance of what the user wants. By separating these repetitive object creations into a factory class, when new classes are added, only the factory class need to be updated.
2. To create object without knowing its class name. When using the concrete classes, the developer has to remember the class names. In factory pattern, choosing what type of object to be created is delegated to the factory class. Usually this is done by sending a parameter. Based on the parameter passed to the factory, the factory creates an instance of a certain type/class.

public final class DocumentFactory {
   XDocument document;
   XDocument getDocument(String type){
      if(type.equals("text"){
         document = new TextDocument();
      }
      else if(type.equals("sheet"){
         document = new SpreadSheet();
      }
   return document;
   }
}

public interface XDocument{
   open();
}

public class TextDocument implements XDocument{
   //concrete class for Text documents
   open(){
      //method to open text document
      System.out.println("opening a text document...");
   }
}

public class SpreadSheet implements XDocument{
   //concrete class for spreadsheet documents
   open(){
      //method to open spreadsheet document
      System.out.println("opening a spreadsheet document...");
   }
}

class DocumentProgram{
   public static void main(String[] args){
   //this just created an instance of TextDocument without knowing its class name.
   XDocument doc = df.getDocument("text");
   doc.open();
   }
}