1Elementary Application Editing Techniques in NetBeans CS288, Autumn 2005 Lab 001 Purpose This document will look at how to define simple fields and methods for the Buildings class. It will also introduce you to basic debugging within NetBeans, and how to use command line arguments within the code. You have already set up the Building class within the CS288 Java project using NetBeans before starting this exercise (Lab 000). To continue with this exercise start NetBeans with the CS288 project open. Note: In using this document it is possible to paste text directly into NetBeans. That means when defining new terms in NetBeans their value can be copied directly from here, which will remove the possibility of mistyping values. If you are reading the PDF version of the document, then clicking on the ‘Select’ icon activates text selection: Items can be selected and copied in the usual way after choosing this tool. Setting Up Fields We will modify the Building class to include some attributes of a physical building, such as an office or home. To start with we will suppose that we want to record the owner/tenant of a building together with the street name and number where the building is physically located. Right click on Fields for the Building class: 2Click on the Add Field option. When the dialog box appear fill in the values as shown to create a new field streetName with type String: Then click OK. Note we have declared access to the field as ‘private’. That means direct access to the field is forbidden outside of the class itself. The Building class view should now look like: 3Double clicking on streetName will bring the declaration into the source editor window: Next we will add a field for the street number of the Building. This field will be of type ‘Double’. NOTE, Java has two closely related but DIFFERENT types: • double • Double The only difference between their names is that one begins with upper case D, the other with lower case d. The ‘double’ type is a representation of a real number that is a raw data type, rather than a proper Java class. The ‘Double’ type is a proper class that has various methods that can be called as with any Java class. The compiler will be totally unforgiving if you confuse the two! As above, add a new field to the Building class. Name the field streetNumber. Give the new field the type Double. This type is not available on the drop down list of default types (although watch out as ‘double’ is one of the defaults available). So you must enter ‘Double’ by typing it in from the keyboard: 4Next add another field, occupantName of type String. At this point NetBeans should display the class structure something like this: Setting up Encapsulation Methods The safe way to modify and access field values is by using methods specifically for that purpose. We have already declared the fields for this class to be private, which means there is no way to access them directly from outside of the class. 5This technique is so common there are templates within NetBeans that can be set-up from the menu. To protect access to a class field by use of such methods is known as encapsulation. Within the project view double-click on the occupantName field. This will bring the declaration of the occupantName field into view within the text editor pane of NetBeans. Right click on the declaration within the text editor: Choose the ‘Encapsulate Fields’ option as shown. A dialog box will now appear that will let you choose which fields to encapsulate. To save time click on each field so that all three will be encapsulated at the same time: 6Then click ‘Next’. A Refactoring pane should now open at the bottom of the main NetBeans IDE: Click on DoRefactoring. The project view will now have several new method entries: 7Also the source editor will contain templates for the various set and get methods: Because we are only dealing with a very simple class these methods do little other than return the values of the fields in question. However, for more complex classes it may well be the case that the bare value of a field is not returned in full, but rather just the salient attribute for that field. For example, it may be that a field is itself a complex class and the get method only returns one aspect of that class. 8Note the use of the keyword ‘this’ in the set methods. Although this is correct Java, for this example it is redundant. Also it can be somewhat confusing. To clarify the set methods edit the source code as follows. Edit the definitions of each of the set methods to change them to the following: public void setStreetName(String newStreetName) { streetName = newStreetName; } public void setStreetNumber(Double newStreetNumber) { streetNumber = newStreetNumber; } public void setOccupantName(String newOccupantName) { occupantName = newOccupantName; } The above text can be pasted directly into the NetBeans editor to avoid mistyping the text. Next click on the ‘Clean and Build Main project’ icon. If the changes have been correctly made the Output pane should look something like this: Using Command Line Arguments in the Main Method We will now edit the main method to allow values for an object to be initialised using the command line arguments. This will allow a Building object to be given initial values that can change with each invocation of the Java application without having to recompile the application each time. In later labs you will see how to allow user input in a friendlier manner, but for now we will have to live with command line options. Double click on the main method in the project view to bring it into focus in the editor pane. Create a new Building object to use in the main method by editing the method to be this: public static void main(String[] args) { Building b1 = new Building(); } 9Type ‘b1.’ on the next line, don’t forget the period ‘.’. NetBeans will now open up a dialog box of possible fields and methods that belong to the b1 object that can be invoked at this point. Scroll down to the setOccupantName method and double click it. Next edit the resulting code so that it looks like this: public static void main(String[] args) { Building b1 = new Building(); b1.setOccupantName(args[0]); } Note that the main method has as its parameter the String array args. The first value of this array is used as the parameter for the setOccupantName method of object b1 in the following line. Repeat the above process (or just paste in the code below) so that the main method looks like this: public static void main(String[] args) { Building b1 = new Building(); b1.setOccupantName(args[0]); b1.setStreetName(args[1]); } We also want to use one of the command line arguments for the initial value of the street number of b1. However to do so we must parse the string value into an integer value. Edit the main method again to become this: public static void main(String[] args) { Building b1 = new Building(); b1.setOccupantName(args[0]); b1.setStreetName(args[1]); Double stNum = Double.parseDouble(args[2]); b1.setStreetNumber(stNum); } Variable stNum is just a placeholder that makes the code more readable. We have now modified the main method so that initial values for the building object b1 will be read in from the command line arguments. Next we can define within 10 NetBeans what command line arguments should be used. Before that to check that you have correctly made the changes in this section click on the Clean and Build Main Project icon. Check that the compilation does not report any errors. To add values for the command line parameters right click CS288 in the project pane. Choose the properties option. Click on the running project field. Add “Mr Jones”, “High Street” and “32” to the arguments field as shown. Using the Debugger to check values at run time. Right click on the b1.setStreetNumber(stNum); line within the main method. Select the Toggle Breakpoint option from the menu. Click on the Debug Main Project icon. 11 The Building application will now be run in debug mode. The code will be executed until it reaches the breakpoint, when execution will stop and we can examine what has happened to the b1 object so far. A new pane will appear at the bottom of the NetBeans main window. Click on the local variables tab and you should see something like this: Note that stNum has the value 32.0, but this has not yet been assigned to the streetNumber field. Click on the ‘Step Over’ icon. The local variables will change to this: The streetNumber field now also has the value 32.0. Click on the ‘Continue’ icon and execution will continue until the end of the application. Standard Output 12 Applications can print directly to standard output to provide a basic but more sensible way to see values for object fields. Change the main method so that it becomes as shown: public static void main(String[] args) { Building b1 = new Building(); b1.setOccupantName(args[0]); b1.setStreetName(args[1]); Double stNum = Double.parseDouble(args[2]); b1.setStreetNumber(stNum); System.out.println("Occupant name is " + b1.getOccupantName()); System.out.println("Street Name is " + b1.getStreetName()); System.out.println("Street Number is " + b1.getStreetNumber()); } Click on the ‘Clean and Build Main Project’ icon. Click on the ‘Run Main Project’ icon. The output window should look like this: init: deps-jar: compile: run: Occupant name is Mr Jones Street Name is High Street Street Number is 32.0 BUILD SUCCESSFUL (total time: 0 seconds) The output window is used both for messages from the compiler and the run time environment, but also to show print statements to standard output. Summary You have now added the following fields and methods to the Buildings class: • streetName • streetNumber • occupantName Together with encapsulation methods for each field. Also you have added statements that use command line arguments to initialise fields for an object. Also the application prints to standard output. Finally you have used the debugger to check that values were correctly assigned to fields during runtime.