1

1v1.6 08/02/2006

Overview of Eclipse Lectures

1. Overview

2. Installing and Running

3. Building and Running Java Classes

4. Refactoring

5. Debugging

6. Testing with JUnit

7. Version Control with CVS

3. Building and Running Java Classes

4. Refactoring Lecture 2

2v1.6 08/02/2006

Module Road Map1. Overview2. 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. Refactoring5. Debugging6. Testing with JUnit7. Version Control with CVS

2

3v1.6 08/02/2006

Building and Running Java Classes » 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)

4v1.6 08/02/2006

Building and Running Java Classes » Using Quick Fix

� Useful if Java compiler shows errors

� Gives options for fixing the errors

� Activated through Edit » Quick Fix menu option

Error indication

3

5v1.6 08/02/2006

Building and Running Java Classes »

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

6v1.6 08/02/2006

Building and Running Java Classes » Running Java Classes

� To Run Java application

� Choose Run »

Run… from the

menu

� Standard Java

output is

displayed in the

console window

4

7v1.6 08/02/2006

Building and Running Java Classes » Console View

� Represents standard Java console

� Opens by default when standard Java output

is used

� Can also be open from Window » Show Viewmenu System.out.println("Hello World");

8v1.6 08/02/2006

Building and Running Java Classes » 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

5

9v1.6 08/02/2006

Building and Running Java Classes » Scrapbook…

� It is created by selecting a project and choosing New »Other…from the Package Explorer’s context menu

� This opens up the Newdialog box

� Expand Java

� Expand Java Run/Debugunder Java

� Select Scrapbook page and click Next.

� This will open New Scrapbook page

� Enter the name of the page

� Your scrapbook page will become a resource in your project

10v1.6 08/02/2006

Building and Running Java Classes » 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

6

11v1.6 08/02/2006

Building and Running Java Classes » 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

12v1.6 08/02/2006

Building and Running Java Classes » 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 run Java code

� How to use the Scrapbook

7

13v1.6 08/02/2006

Exercise 2

� Create a new class titled NewClass and add it to the package csc517 in the project EgAppyou have created in Exercise 1.

� Add a private integer field (member variable) mVar to the class NewClass.

� Add a constructor method to accept an integer to initialize the private integer field mVar.� Add a public method printField that takes no parameters and returns void.

� Add code to the printField method to print the value of the private variable mVar to the standard output.

� Instantiate an object of type NewClass in the main() routine of the MainClass.

� Call the printField routine of the NewClass object.

� Run the project EgApp.

� What do you see in the Console window?

14v1.6 08/02/2006

Module Road Map

1. Overview

2. Installing and Running

3. Building and Running Java Classes

4. Refactoring

� Why Refactoring?

� Examples

� Common Refactorings

5. Debugging

6. Testing with JUnit

7. Version Control with CVS

8

15v1.6 08/02/2006

Refactoring » 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

16v1.6 08/02/2006

Refactoring » What is Refactoring?

� Refactoring is the process of changing a

software system so that

� the external behavior is not altered, but

� the internal structure is improved.

� Refactoring (http://www.refactoring.com/) is a

“behavior-preserving transformation.”

9

17v1.6 08/02/2006

Refactoring » Why Refactoring?

� Methods might no longer do (only) what their

name suggests.

� Functionality that should be in two different classes might be in the same class.

� Functionality that should be in one class

might be duplicated in two or more classes.

� Improve the design of existing code.

� Gain a better understanding of the code.

18v1.6 08/02/2006

Refactoring » Example

� Consider a method for computing the room charge for a hotel:

public double public double public double public double getRoomChargegetRoomChargegetRoomChargegetRoomCharge()()()(){{{{double double double double roomChargeroomChargeroomChargeroomCharge = 0.0;= 0.0;= 0.0;= 0.0;... code to compute room charge...... code to compute room charge...... code to compute room charge...... code to compute room charge...return return return return roomChargeroomChargeroomChargeroomCharge;;;;

}}}}� What other factors might go into computing

the room charge?

10

19v1.6 08/02/2006

Refactoring » Example

� Of course, to print out a bill for a customer, we also need to include incidentals and taxes …public double public double public double public double getRoomChargegetRoomChargegetRoomChargegetRoomCharge()()()(){{{{ double double double double roomChargeroomChargeroomChargeroomCharge = 0.0;= 0.0;= 0.0;= 0.0;... code to compute room charge...... code to compute room charge...... code to compute room charge...... code to compute room charge...//now add the incidentals to //now add the incidentals to //now add the incidentals to //now add the incidentals to roomChargeroomChargeroomChargeroomCharge... code to add up incidentals ...... code to add up incidentals ...... code to add up incidentals ...... code to add up incidentals ...//now add the tax for the room to the charge//now add the tax for the room to the charge//now add the tax for the room to the charge//now add the tax for the room to the charge...several lines of code to compute the tax......several lines of code to compute the tax......several lines of code to compute the tax......several lines of code to compute the tax...return return return return roomChargeroomChargeroomChargeroomCharge;;;;}}}}

� What’s inelegant about this method now?� 3 sets of calculations in one function. Method does 3 things.

� The name is not illustrative of what the method does.

20v1.6 08/02/2006

Refactoring » Example

� Better: Changing the name of the method (for example, calculateCustomerChargecalculateCustomerChargecalculateCustomerChargecalculateCustomerCharge).

� Does this fix the problem?

� No, We also need to change the name at all call sites.

� We need to update the documentation.

� If this method overrides a method in another class, the

other name may need to be changed too. Ditto if this method implements an interface.

� This is known as the Rename Method refactoring.

11

21v1.6 08/02/2006

Refactoring » Example

� Let’s refactor our getRoomChargegetRoomChargegetRoomChargegetRoomCharge()()()() method.public doublepublic doublepublic doublepublic double calculateCustomerChargecalculateCustomerChargecalculateCustomerChargecalculateCustomerCharge()()()(){{{{ double double double double roomChargeroomChargeroomChargeroomCharge ==== getRoomChargegetRoomChargegetRoomChargegetRoomCharge();();();();double incidentals =double incidentals =double incidentals =double incidentals = getIncidentalsgetIncidentalsgetIncidentalsgetIncidentals();();();();double tax =double tax =double tax =double tax = getTax(roomChargegetTax(roomChargegetTax(roomChargegetTax(roomCharge, incidentals);, incidentals);, incidentals);, incidentals);return return return return roomChargeroomChargeroomChargeroomCharge + incidentals + tax;+ incidentals + tax;+ incidentals + tax;+ incidentals + tax;}}}}� What have we done?

� We defined additional methods to compute incidentals, tax, etc.

� In order to do this, we added local variables for the quantities that are being calculated in the new methods.

� Some pre-existing local variables ended up being parameters to the new method.

� The returned value is different from what was returned in the pre-existing method.

22v1.6 08/02/2006

Refactoring » Common Refactorings

� Rename

� Methods, Fields, Packages, Projects, Parameters, or

Local Variables

� Encapsulate Field (generate getter and setter)

� Pull up a Field or Method (into superclass)

� Push down a Field or Method (into subclass)

� Extract Method, Local Variable, or Constant from an Expression

� Change Method Signature

12

23v1.6 08/02/2006

Refactoring » Renaming a Method Using Eclipse

� In a Java view showing methods (e.g., the Outline view) select the method to be renamed.

� From the view's pop-up menu, select Refactor » Rename, or select Refactor » Rename from the global menu baror

� In a Java editor, select a reference to or the declaration of the method to be renamed.

� From the editor's pop-up menu, select Refactor » Rename, or select Refactor » Rename from the global menu bar.

� This pops up the Rename Methoddialog box.

� Click Preview to preview the changes, or click OK to perform the refactoring.

24v1.6 08/02/2006

Refactoring » Encapsulating a Field

� The Encapsulate Field refactoring can be used to convert a public instance variable into a private instance variable with accessorfunctions.

� Example: Inelegant code—public public public public PublicFieldClassPublicFieldClassPublicFieldClassPublicFieldClass{{{{public String name ;public String name ;public String name ;public String name ;}}}}public public public public OtherClassOtherClassOtherClassOtherClass{{{{public static void public static void public static void public static void main(Stringmain(Stringmain(Stringmain(String[] [] [] [] argsargsargsargs){){){){PublicFieldClassPublicFieldClassPublicFieldClassPublicFieldClass example = new example = new example = new example = new PublicFieldClassPublicFieldClassPublicFieldClassPublicFieldClass();();();();example.nameexample.nameexample.nameexample.name = "Joe";= "Joe";= "Joe";= "Joe";System.out.println("MySystem.out.println("MySystem.out.println("MySystem.out.println("My name is " + name is " + name is " + name is " + example.nameexample.nameexample.nameexample.name););););}}}}}}}}

13

25v1.6 08/02/2006

Refactoring » Encapsulating a Field

� After refactoring, we have …public public public public EncapsulatedFieldClassEncapsulatedFieldClassEncapsulatedFieldClassEncapsulatedFieldClass{{{{private String name;private String name;private String name;private String name;public String public String public String public String getNamegetNamegetNamegetName(){(){(){(){return name;return name;return name;return name;}}}}public public public public setName(StringsetName(StringsetName(StringsetName(String newNamenewNamenewNamenewName){){){){name = name = name = name = newNamenewNamenewNamenewName;;;;}}}}}}}}public public public public OtherClassOtherClassOtherClassOtherClass{{{{public static void public static void public static void public static void main(Stringmain(Stringmain(Stringmain(String[] [] [] [] argsargsargsargs){){){){EncapsulatedFieldClassEncapsulatedFieldClassEncapsulatedFieldClassEncapsulatedFieldClass example = example = example = example = new new new new EncapsulatedFieldClassEncapsulatedFieldClassEncapsulatedFieldClassEncapsulatedFieldClass()()()()example.setName("Joeexample.setName("Joeexample.setName("Joeexample.setName("Joe") ;") ;") ;") ;System.out.println("MySystem.out.println("MySystem.out.println("MySystem.out.println("My name is " +name is " +name is " +name is " +example.getNameexample.getNameexample.getNameexample.getName()) ;()) ;()) ;()) ;}}}}}}}}

26v1.6 08/02/2006

Refactoring » Encapsulating a Field Using Eclipse

� Select the field in one of the Java views (e.g., Outline, Package Explorer or Members view).

� From the field's pop-up menu, select Refactor » Encapsulate Field… , or from the menu bar, select Refactor »Encapsulate Field…

� Alternatively, in the Java editor, select the field.

� From the menu bar, select Refactor »Encapsulate Field… , or from the editor's pop-up menu, select Refactor »Encapsulate Field…

� This pops up the Encapsulate Fielddialog.

� Type the names of the accessor routines in the Getter name and Setter name text fields.

� Click Preview to preview the changes or Click OK to perform refactoring.

14

27v1.6 08/02/2006

Refactoring » Pull Up Method

� Moves a field or method to a superclass of its declaring class.

� Suppose you have the same method—or nearly the same method—in two different classes in your system. It may be a good idea to centralize the behavior in a superclass.public class Employee extends Person { String getName() {... }}public class Student extends Person { String getName() {... }}

28v1.6 08/02/2006

Refactoring » Pull Up Method

� After the Pull up Method refactoring is applied …

public class Person {String getName() {...}

}

15

29v1.6 08/02/2006

Refactoring » Pull Up Method Using Eclipse

� In a Java view (e.g., Outline, Package Explorer, Members), select the members that you want to pull up.

� From the menu bar, select Refactor » Pull Up or from the pop-up menu, select Refactor» Pull Up.

� This pops up the Pull updialog.

� Select the methods to pull up and their new declaring class. Click Next.

� Select the methods to be removed in the subtypes after pull up and click Next to review the changes.

30v1.6 08/02/2006

Refactoring » Push Down Method

� Reverse of Pull up Method.

� Moves a set of methods and fields from a

class to its subclasses.

� Can be used when some of the subclasses

do not use a method defined in the

superclass.

16

31v1.6 08/02/2006

Refactoring » Push Down Method Using Eclipse

� In a Java view (e.g., Outline, Package Explorer, Members), select the members that you want to push down.

� From the menu bar, select Refactor » Push Down or from the pop-up menu, select Refactor » Push Down.

� The Push Down dialog will open.

� Click Preview to preview the changes or click OK to perform the refactoring.

32v1.6 08/02/2006

Refactoring » Extracting a Local Variable

� An expression that occurs in more than one place is replaced with a local variable, whose value is calculated only once.

� If a program needs to use the same value in multiple places, it can be calculated only once and then used wherever needed.

� Advantages

� Makes the code more efficient.

� Makes the code more readable.

� Creates a single point of maintenance for the logic of

computing the expression.

17

33v1.6 08/02/2006

Refactoring » Extracting a Local Variable Using Eclipse

� In a Java editor, select the expression that you want to extract to a local variable.

� From the editor's pop-up menu, select Refactor »Extract Local Variable or from the menu bar, select Refactor» Extract Local Variable.

� This will open the Extract Local Variable dialog box.

� Type the name of the variable in the Variable name text field.

� Click Preview to preview the changes or click OK to perform the refactoring.

34v1.6 08/02/2006

Refactoring » Extracting a Method

� Creates a new method containing the statements or expression currently selected and replaces the selection with a reference to the new method.

� Advantages

� Code readability

� Minimize code duplication

18

35v1.6 08/02/2006

Refactoring » Extracting a Method Using Eclipse

� In an editor, select a set of statements or an expression from a method body.

� From the pop-up menu in the editor, select Refactor »Extract Method from the menu bar, select Refactor »Extract Method.

� This opens the Extract Method dialog box.

� Type the method name in the Method name text field.

� In the Access Modifier list, specify the method's visibility (public, default, protected, or private).

� Click Preview to preview the changes or click OK to perform the refactoring.

36v1.6 08/02/2006

Refactoring » Change Method Signature

� Select the method in a Java view (e.g. Outline, Package Explorer, Members).

� From the menu bar, select Refactor »Change Method Signature or from the method's pop-up menu, select Refactor » Change Method Signature.

� This opens the Change Method Signature dialog box.

� Use the Access Modifier drop-down to control the method's visibility.

� Change the method's return type or name by editing the provided text fields.

� Select one or more parameters and use the Up and Down buttons to reorder the parameters (you can see a signature preview below the parameter list).

� Use the Add button to add a parameter; you can then edit its type, name and default value in the table. � Switch to the Exceptions tab to add or

remove thrown exceptions. Click Preview to preview the changes

19

37v1.6 08/02/2006

Other Refactorings Supported by Eclipse

� Renaming

� a package

� a compilation unit

� a type

� a local variable

� method parameters

� Extracting

� a constant

� an interface from a type

� Inlining

� a local variable

� a method

� a constant

� static members between types

� an instance method to a component

� Converting

� a local variable to a field

� an anonymous inner class to

a nested class

� a nested type to a top level

type

� Replacing

� references to a type with

references to one of its

supertypes

� a single reference to a type

with a reference to one of its

supertypes

� an expression with a method

parameter

� constructor calls with factory

method invocations

38v1.6 08/02/2006

Refactorings Supported by NetBeans (v 5.0)

� Renaming

� a package

� a compilation unit

� a type

� a local variable

� method parameters

� Extracting

� a constant

� an interface from a type

� Inlining

� a local variable

� a method

� a constant

� static members between types

� an instance method to a component

� Converting

� a local variable to a field

� an anonymous inner class to

a nested class

� a nested type to a top level

type

� Replacing

� references to a type with

references to one of its

supertypes

� a single reference to a type

with a reference to one of its

supertypes

� an expression with a method

parameter

� constructor calls with factory

method invocations

20

39v1.6 08/02/2006

Exercise 3

� Change the name of the class NewClass that was created in Exercise 2 in the project EgApp to RefactoredClass.

� Change the name of the method printField in the class RefactoredClass to refactoredPrintField.

� Review the changes that will be made by Eclipse using the Preview option.

� Compile and Run the project EgApp.