Objective

In this homework you will practice defining classes and testing modules for classes you define.

Overview

For this assignment you will implement a class called Road which represents a road. The class implements several methods for the manipulation of Road objects. More details about the class are provided in the Specifications section. You may want to take a look at the Sample Run section before you read the detailed description. It presents a driver program (and expected output) that makes use of the Road class. Although this homework is considered an open homework, try to complete it on your own.  Future homeworks will be closed homeworks.  Please see the Open/Closed Policy on the class web page.

In addition to the program, you must submit a testing class, and a time log.

This homework will be graded as follows:

• 85% - Implementation (including 10% for style)
• 10% - Test class
• 5% - Time log

Specifications

Code Distribution

You can access the files associated with this homework by checking out the project labeled p4. In the distribution you will find:

• Driver.java - Sample driver for the Road class and the one presented in the Sample Run.
• timelog.txt
• PublicTests.java - The JUnit with the set of public tests available in the submit server.
• MyTests.java - Shell for a class you must complete. This class represents a Test class.

Road Class

Overview

The goal of this project is for you to provide a full implementation of the Road class. This class represents a road by keeping track of the road's number, name, and length.

Variables

Instance Variables

The Road class defines two private String reference variables called name and number representing a road's name and number, respectively.  In addition, a private double variable called length represents a road's length.

Static Constants

The class defines the following constants:

Name	Type	Access Specifier	Value
DEFAULT_NUMBER	String	private	"NONUMBER"
DEFAULT_NAME	String	private	"NONAME"
DEFAULT_LENGTH	double	private	0.0
BAR_FORMAT	int	public	1
TAG_FORMAT	int	public	2

Private Non-Static Methods

• setInstanceData - This method takes three parameters called theNumber, theName, and theLength which represent a road's  number, name, and length, respectively. The method initializes the number and name with duplicates of the String objects represented by the parameters.

Public Non-Static Methods

• Default Constructor - Initializes the object with the values DEFAULT_NUMBER, DEFAULT_NAME,  and DEFAULT_LENGTH.
• Additional Constructor - This method takes three parameters called theNumber, theName, and theLength, which represent a road's  number, name, and length, respectively. The method initializes the number and name with duplicates of the String objects represented by the parameters.
• Copy Constructor - This method duplicates the String objects associated with the parameter Road object. The formal parameter for this constructor is a reference to an object of the Road class.
• toString - Returns a string with the instance data formatted as follows:

            <roadOutput> → <roadNumber>|"<roadName>"|<roadLength>

            <roadNumber>, <roadName>, and <roadLength> represent the road's number, name, and length respectively.

            For example, a road named "Interstate 95", whose number is "I95" and length is 20.5 miles has the following format:

                                                                I95|"Interstate 95"|20.5

• getNumber - Returns the number reference.
• getName - Returns the name reference.
• getLength - Returns the road's length.
• setName - This method takes a String reference as a parameter and initializes the name field with a copy of the parameter. 
• setLength - This method takes a double as parameter and initializes the road's length with the parameter's value.
• equals - This method has a boolean return type and a Road reference as parameter. It returns true if the current object and the parameter represent the same road. When comparing roads, length is ignored.  The strings representing a road's number and name must match exactly (case is not ignored) the corresponding fields of a second road in order for the roads to be considered equal.
• compareTo - This method returns an integer and takes a Road reference as a parameter. This method allows us to compare two roads. The method will return -1 if the current object has a length that is less than the parameter, 0 if the current object and the parameter have the same length,  and 1 if the parameter has a length than is greater than the current object.

Public Static Method

• format - This method has a String reference as return type and two parameters: a reference to a Road object and an integer. The method will create a String object based on the provided Road reference and the format specified by the integer value. You may assume the integer value input is valid (no error checking).

In the following description <roadNumber>, <roadName>, and <roadLength> represent the instance variables associated with a Road object. The possible format choices are:

• BAR_FORMAT → The format defined by <roadOutput> above.
• TAG_FORMAT →

"Road Number: "<roadNumber>

"Road Name: "<roadName>

"Road Length (miles): "<roadLength>

 

• createRoute - This method has as parameters two Road references named roadOne and roadTwo.  This method will create a new Road object based on the parameters.   The new road's number will be the concatenation of roadOne's number and roadTwo's number, separated by a comma.  Likewise, the new road's name will be the concatenation of oadOne's name and roadTwo's name, separated by a comma.  The new road's length will be the sum of roadOne's length and roadTwo's length.

Requirements (Read Carefully)

• You may assume we will not pass a null reference for any method that requires a reference parameter (e.g., no null references for equals).
• You must avoid code duplication. Code duplication can be avoided if methods depend on other methods of the class to implement their functionality. This project has been designed with this in mind. As you implement the Road class think about how you can avoid code duplication for each of the methods you must implement. You will lose significant points if you duplicate code even if your implementation is correct.
• You must use meaningful variable names and good indentation.
• You cannot add any additional classes beyond the ones specified above.
• Testing class - Testing your classes is a very important skill. For this project you must complete the MyTests.java file with a set of tests that verify the correctness of each of the methods you have defined. As long as you have defined one test for each method you will be fine. All the tests can be in one method or multiple methods. That is up to you. The only restriction you have is that we must be able to see the results of ALL your tests by just running the main() method of the class. When visiting the TA during office hours we may ask you to present this file to get help.  Write these tests as you complete your implementation.
• You may not modify the prototypes (public/private, name, parameters, return type) of any of the Road methods.
• Do not define any additional instance variables or methods beyond the ones specified above.
• Do not use any new language constructs, e.g., arrays, that have not been presented in class.
• Use the Eclipse submit option for your submission. If you are having problems with this, please contact us.

. Submission (Please Read)

• Immediately after reading this description, check out the code distribution and submit. You need to make sure that you can submit your project. Don't wait until the day before the project is due to submit your project.
• Submit your project using the submit project option associated with Eclipse. Remember to complete your time log before submitting your homework.
• After you submit a project, you must verify it generates the expected results by accessing the submit server. The submit server has now being configured to test your program against a set of tests. Some of these are are the ones available in the file PublicTests.java. In addition, you can ask for release testing as described in lecture. If you have doubts about the testing environment we just described SEE THE TA DURING OFFICE HOURS IMMEDIATELY. Do not wait until the day the project is due as you may not be able to get the help you need.

Sample Run

The following is a sample run of a Driver class that relies on the Road class you must implement. The Driver is provided along with the expected output. Keep in mind that the submit server tests don't use this driver. This Driver is to help you understand the functionality associated with the different methods of the Road class.

Driver

public class Driver {
	public static void main(String[] args) {
		Road roadOne = new Road();
		System.out.println(roadOne);
		

		System.out.println("*****Comparison*****");
		Road roadTwo = new Road("I95", "Interstate 95", 20.5);
		Road roadThree = new Road("27", "Baltimore Ave.", 8);
		System.out.println(roadTwo);
		System.out.println(roadThree);
		if (roadTwo.compareTo(roadThree) > 0) 
			System.out.println("roadTwo longer than roadThree");
		else 
			System.out.println("roadTwo shorter or equal to roadThree");
		

		
		System.out.println("*****Duplicate*****");
		Road roadFour = new Road(roadThree);
		System.out.println(roadFour);
		System.out.println("*****Formatted*****");
		String formatted = Road.format(roadFour, Road.TAG_FORMAT);
		System.out.println(formatted);
		if (roadThree.equals(roadFour)) 
			System.out.println("Roads are considered the same.");
		else
			System.out.println("Roads are different.");
		

		System.out.println("*****Merging Roads*****");
		Road roadFive = Road.createRoute(roadTwo,roadThree);
		System.out.println(roadFive);
		System.out.println("=====");
		Road roadSix = Road.createRoute(roadThree,roadTwo);
		System.out.println(roadSix);
		System.out.println("=====");
		Road roadSeven = new Road("210", "Rhode Island Ave.", 34);
		Road roadEight = Road.createRoute(roadSix, roadSeven);
		System.out.println(roadEight);
		System.out.println("=====");
	}
}

Output

NONUMBER|"NONAME"|0.0
*****Comparison*****
I95|"Interstate 95"|20.5
27|"Baltimore Ave."|8.0
roadTwo longer than roadThree
*****Duplicate*****
27|"Baltimore Ave."|8.0
*****Formatted*****
Road Number: 27
Road Name: Baltimore Ave.
Road Length (miles): 8.0
Roads are considered the same.
*****Merging Roads*****
I95,27|"Interstate 95,Baltimore Ave."|28.5
=====
27,I95|"Baltimore Ave.,Interstate 95"|28.5
=====
27,I95,210|"Baltimore Ave.,Interstate 95,Rhode Island Ave."|62.5
=====

Challenge Problem

Remember that you are not required to implement the following problem. Please visit the course web page for information regarding challenge problems.

The challenge problem for this homework consists of adding a non-static method name partOfRoute.  This method will return true if the current object represents a road that is part of the route represented by the Road reference parameter, and false otherwise. 

Web Accessibility