Objective

To practice using the String class, writing classes from scratch, and writing JUnit test cases.

Overview

Note that this project is CLOSED.  Please review the course policy on open/closed projects before you begin.

For this project you will write three classes:  Name, Address, and Letter.  You will also write an extensive set of JUnit tests, which should test all of the methods you have written in your classes.  This project is different from most projects in this course, because there is no main() method anywhere.  What you are creating are three re-useable modules (Name, Address, and Letter) that could later be made part of a complete program.

Put all of your work (Name.java, Address.java, and Letter.java) in the folder we have provided labeled "src".

Tests

• PublicTests -- you have been given a file called "PublicTests.java".   Here we show you the actual code for a few tests that will be used by the submit server to grade your project.  These tests are very simple, but use them as examples to give you ideas about how to go about writing tests of your own.  Take a look at the code for these tests, and try them out -- you'll see that they test some of your constructors and your toString methods.
• ReleaseTests -- as with most projects in this course, we have come up with several (11) release tests, which the submit server will use to grade your project.  You cannot see the code for the release tests, but you can see the results as usual by using one of your "tokens".
• StudentTests -- you have been given a file called "StudentTests.java".  It contains just a shell of a typical JUnit test suite.  You must fill in the shell with your own JUnit tests, which are designed to test the classes you are writing as thoroughly as possible.  You will be graded on the quality of the tests.  The more thorough your tests are, the better.  EVERY method you write in the Name, Address, and Letter classes should be tested -- from the simplest access method to the more complex ones.  You should write many very short tests, with names that describe what features are being tested.  Your Name, Address, and Letter classes must pass all of your own tests!

Java API that will be helpful

Before beginning this project, you may want to look over the online documentation for the Java String class.  You will need to make use of some of the methods you can read about there.  You should also familiarize yourself with the static method called "isLetter", which is part of the Character class.  You'll need it!

Writing the Classes

We are leaving many decisions about the implementation of these classes for you to decide.  Below are descriptions of the classes you must write.

Name Class

The "state" for a Name object consists of two fields, described below.  You may also include any static constants that you think are useful.

Private fields

• first name (represented as a String)
• last name (represented as a String)

The methods you must write are described below.  As mentioned previously, we are intentionally leaving a lot of decisions about how to write these methods for you to decide.  In particular, you must decide which of these things (if any) should be static.  In addition to the methods below, please feel free to also include as many private methods as you find useful.

Public methods

• default constructor -- sets both first and last names to "Unknown".
• constructor with two String parameters -- the first parameter represents the last name, the second parameter represents the first name.
• constructor with one String parameter -- the parameter represents both the first and last names together, but separated by a comma.  For example, if the parameter is "Smith, Bob", then the constructor must set the last name to "Smith" and the first name to "Bob".  You may assume that there will always be a comma between the names, and exactly one space after the comma (and no other spaces or stray punctuation marks anywhere.)
• copy constructor -- a constructor with one parameter (a Name).  Makes the current object a copy of the parameter.
• getFirst -- accessor for first name
• getLast -- accessor for last name
• setFirst -- takes a String parameter.  This method will first verify that the name proposed is valid (by calling the isValidName method, described later).  If the name is valid, sets the first name equal to the parameter; otherwise, sets the first name equal to null.
• setLast -- takes a String parameter.  This method will first verify that the name proposed is valid (by calling the isValidName method, described later).  If the name is valid, sets the last name equal to the parameter; otherwise, sets the last name equal to null.

Important:  Anyplace the first and last name are set, the mutators above (setFirst and setLast) should be called.  This includes the constructors that you are writing for this class.

• equals -- takes a Name parameter.  Compares the current object to the parameter and returns type boolean.  The two Name objects are considered equal if both the first names and the last names match.  IMPORTANT:  Ignore case distinction when comparing the names.  In other words, "Smith" and "SmItH" are considered equal.  Also IMPORTANT:  You must check if the parameter is "null" -- if it is, then just return false. 
• compareTo -- takes a Name parameter and returns an int.  Compares the two Name objects (the current object and the parameter) using the usual system for alphabetizing names.  I.e.:  Alphabetize them based on the last name, and only consider the first name in cases where the last names are a tie.  As with the equals method, ignore case distinction when making the comparisons.  If the current object precedes the parameter, return a negative value.  If the parameter precedes the current object, return a positive value.  Return 0 if they tie.  You may assume that the parameter is not null.
• toString -- returns a String in the format:   <firstName> <lastName>, where there is exactly one space between the two names.  For example, if the last name is "Smith", and the first name is "Bob", then the return value should be "Bob Smith".

Private methods

• isValidName(String nameRequested) -- returns true if the parameter represents a valid name.  A name is considered valid if it consists of 20 characters or fewer and each character is an alphabetical letter (A through Z, either upper or lower case.)

Address Class

The "state" for an Address object consists of the following fields:

Private fields

• a name (use a Name object)
• a street address (use a String).  An example might be:  "455 Maple St."
• a city (use a String)
• a state (use a String).  Here we'll store state abbreviations.  For example "MD".
• a zipcode (use a String).  Even though it's a number, we'll store it as a String.  For example:  "20742".

The methods you must write are described below.  As mentioned previously, we are intentionally leaving a lot of decisions about how to write these methods for you to decide.  In particular, you must decide which of these things (if any) should be static.  In addition to the methods below, please feel free to also include as many private methods as you find useful.

Public methods

• constructor that takes three parameters:  A String that represents the name (for example "Smith, Bob"), a String representing the street address (for example "737 Main Street"), a String representing the city, state, and zipcode.  An example of the third parameter would be:  "College Park, MD 20742".  You may assume that the punctuation will be exactly as shown here -- a comma after the city, followed by a space.  The state will always be two letters, the zipcode will always be 5 digits, and there will always be exactly one space between the state and the zipcode.  There will never be any stray punctuation marks, and there will never be any extra spaces after the zipcode.  The constructor must set the five fields for the current object.
• accessors for the five fields.  You must use the names:  getName, getStreetAddress, getCity, getState, getZip.
• an equals method -- takes an Address parameter.  First check if the parameter is null.  If so, return false.  Otherwise, checks if all five fields of the current object match those of the parameter.  You must ignore case distinction when doing the comparisons.
• a toString method.  A typical return value will look like what you see below.  Don't forget that you can use the character '\n' to indicate "new line".

  Bob Smith

  1234 Maple Street

  College Park, MD 20742

Letter Class

The "state" for a Letter object consists of the following fields:

Private fields:

• An Address object representing who the letter is from
• An Address object representing who the letter is going to
• A String representing the "content" of the letter.

The methods you must write are described below.  As mentioned previously, we are intentionally leaving a lot of decisions about how to write these methods for you to decide.  In particular, you must decide which of these things (if any) should be static.  In addition to the methods below, please feel free to also include as many private methods as you find useful.

Public methods

• A constructor that takes two Address parameters -- the first parameter is who the letter is from; the second parameter is who the letter is going to.  Set the content to the String "Empty" (with no punctuation).
• A constructor that takes three parameters -- the first parameter is the Address of who the letter is from; the second parameter is the Address of who the letter is going to; the third parameter is the content.
• A method called "letterToSelf".  This method has one Address parameter.  It has a return value of type Letter.  The method will return a Letter object with the following characteristics:  The "from" address will be equal to the parameter.  The "to" address will also be equal to the parameter.  The content will be "This letter is from <firstName> to <firstName>."  where <firstName> represents the first name of the person whose address was passed in as the parameter.  Note that there is a period at the end of the content message.  For example, if the name of the person in the address being used is "Bob Smith", then the content of the letter will be "This letter is from Bob to Bob.".  Again, the method returns a Letter object.

• A toString method.  A typical return value will look like what you see below.  Don't forget that you can use the '\n' character to indicate the end of a line.

FROM:

Bob Smith

7373 Maple Street

Beltsville, MD 20705

TO:

Jane Doe

97663 Main Street

Arlington, VA 22206

CONTENT:

Hello Jane, How are you?

 

Requirements

• Keep the classes you are writing in the "src" folder, and keep them in the default package (don't specify a package). 
• Do not create any classes other than the three classes mentioned above.
• You must avoid code duplication!  We strongly recommend that you thoroughly read through the ENTIRE project description before beginning.  Some of the methods that you will be writing should make calls to other methods that you are writing. 
• You may write as many extra private methods as you want (including ones inside the StudentTests.java file.)
• We are grading your projects for appropriate commenting.  Each method should have a comment above it.  Other comments should be provided wherever clarification is warranted.
• You must use meaningful variable names and good indentation.
• There is NO input and NO output for this project.
• You should not modify the project specifications. For example, do not add extra behavior or output.
• We use an automated system to grade projects and it will not be able to grade your project if you do not follow the project specifications closely. In particular, you must spell things exactly as we have spelled them and use punctuation exactly as we have.  You do NOT need to worry about how many spaces to put between words in your output -- it doesn't matter.
• Just in case you know what an array is -- you may not use arrays (or any Java collections of any kind) while implementing this project.
• Your program must terminate without using anything like System.exit().  (Don't worry if you don't know what that is.)

Grading

Your grade will be determined as follows:

• Public tests (3) -- 15%
• Release tests (11)  -- 55%
• Student tests -- 20%.  (Your program must pass all of the tests you write.  Your grade on this portion will be based on how thorough your tests are, and/or how well they are written.)
• Style -- 10%