CSSE 220: Object Oriented Software Development
Exam 1, Spring 2008-2009

What does this test cover?

• Using objects (as in WordGames, BallWorlds and BigRational):

  • Constructing objects with the new operator
  • Invoking methods on objects with the dot notation
  • Reading and applying the API (Application Programming Interface) for a class

• How to implement a class (as in WordGames, BallWorlds and BigRational):

  • The process for doing so:
    • Writing documented stubs before coding
    • Writing JUnit tests before coding
    • Using iterative enhancement
  • Implementing an interface
  • Writing constructors
  • Writing methods
  • Using fields, including determining what fields are needed

• Inheritance and its benefits (as in BallWorlds):

  • Extending a class
  • The this and super keywords
  • Visibility modifiers public, protected and private

• Using Java generics (as in BigRational)
• Using the Comparable interface (as in BigRational)
• The Object class and when its methods should be overridden (as in BigRational)
• Throwing and catching Exceptions (as in BigRational)

The Rules

1. Take this exam on Tuesday, April 7 during class (1st and 2nd periods for section 1, 7th and 8th periods for section 2).
2. This test is open-everything, including but not limited to your computer, the Internet, the course web site, Angel, and your textbook(s). BUT:
3. You may NOT communicate with anyone except the exam proctors in any way during this exam, and
4. You may NOT discuss this exam with anyone except the exam proctors in any way from Tuesday at 8 a.m. (when section 1 begins the exam) until Tuesday at 3:25 (when section 2 completes the exam).
5. Time limit: 2 periods (during your regular class time).
   • I expect that 2 periods will be ample for everyone.
   • However, if at the end of the 2 periods you feel that one more period would make a significant difference to you, then:
     1. Commit your work at the end of the 2 periods.
     2. Send me an email alerting me that you are taking an extra period.
     3. When you next have a free hour, but no later than Tuesday at 10 p.m., take an extra hour to complete the exam as best you can. Then commit your work again.

6. Well before the exam (you can do it now):

   • Get the Exam1Problem1 project, as follows:

     1. Unzip this Exam1Problem1.zip file, putting it into your JavaProjects folder.
     2. In Eclipse, choose File ~ Import and import the unzipped Exam1Problem1 project.
     3. Add your Exam1Problem1 project to your individual repository for this course.

   • Get the Exam1Problem2 project, as follows:

     1. Unzip this Exam1Problem2.zip file, putting it into your JavaProjects folder.
     2. In Eclipse, choose File ~ Import and import the unzipped Exam1Problem2 project.
     3. Add your Exam1Problem2 project to your individual repository for this course.

   • Examine those projects so that you are comfortable with them.

7. As you will see below, you will do two problems: one based on the above Exam1Problem1 project and the other based on the Exam1Problem2 project. In each case, you will turn in your work by commiting your projects to your individual repository at the end of the exam.
8. If you have questions about The Rules for this exam, ask BEFORE the exam (like now!).
9. DO prepare hard for this test (by making sure you understand the lessons of WordGames, BallWorlds and BigRational). DON'T get anxious about this test.
   • If you find that you cannot do one (or both) of the questions, I'll meet with you after the test to help you overcome any blind spots and offer you a retest. Don't abuse this privilege (DO prepare for the test!), but I hope that it reduces any anxiety about the test.

Problem 1

You have two choices for this problem: either implement class XXX or implement class YYY [details for each revealed at the exam].

• Implementing class XXX successfully is worth 40 points while implementing class YYY successfully is worth 50 points. Hence, doing XXX limits your overall score on the exam; however, some students may find XXX easier than YYY.
• You follow the same process for either problem.
• You can try one and then switch to the other if you wish. There is no penalty for trying YYY and then reverting to XXX, but pay attention to your time.
• As you will see when the details are revealed at the exam, XXX and YYY are quite similar.

• Step 1: Add documented stubs and commit your work.
• Step 2: Write JUnit tests and commit your work.
• Step 3: Implement and test/debug and commit your work.

1. Do one of the following:

   1. Add a XXX class to your Exam1Problem1 project, and have XXX implement StringTransformable as follows: [details revealed at the exam].
   2. Add a YYY class to your Exam1Problem1 project, and have YYY implement StringTransformable as follows: [details revealed at the exam].

   In either case, keep in mind this grading rubric (this is the rubric for YYY; take 80% of each item to get the rubric for XXX):

   • 10 points: Did you commit appropriately documented stubs?
   • 5 points: Did you commit the required JUnit test cases [details revealed at the exam]?
   • 20 points: Is your YYY class correct?
   • 10 points: Are your test cases correct?
   • 5 points: Does your YYY class obey our code conventions?

   Note that your JUnit test class need not be documented and may violate style rules (although I hope that it does not do so).

2. Don't forget to commit your Exam1Problem1 project to your individual repository when you are done working on the project, as well as after each of Steps 1 and 2.

Problem 2

1. Add a Bonus class to your Exam1Problem2 project, and have Bonus extend Bouncer.
2. A Bonus behaves just like a Bouncer, except [details to be revealed at the exam]. Implement Bonus, keeping in mind this grading rubric:
   • 20 points: Does the Bonus operate per the specification?
   • 20 points: Does Bonus make good use of inheritance?
   • 5 points: Is Bonus documented appropriately?
   • 5 points: Does Bonus obey our code conventions?
3. When you are done, commit your Exam1Problem2 project to your individual repository.