Skip to main content.

Assignment 4: Intro to Object-Oriented Programming and Inheritance in Java

Objectives:

Due: Before next Tuesday 11:59 p.m.

Recommendation: Complete the first two parts before Friday's class and part 3 before Monday's class. Start part 4 before Monday's class.

Set Up

Cloning the Repository

In your terminal, go to the directory where you are keeping your repositories for CSCI209. Clone the repository for this assignment. Add your name to the README file.

Part 1: Fixing A Program (40)

Assign4.java contains at least 5 errors. Some are compiler errors that the compiler will catch. Others are logic errors that you need to catch. One is an access modifier error that is not good OO style.

Comment out the original code and explain the cause of the error. Then, correct the code. Make as few changes as necessary to fix the code.

After you're sure the program behaves correctly, save the output in a file called debugged.out. Add the file to your repository.

Part 2: Creating a Birthday Class (40)

Overview: Create a Birthday (but not birth date) class.

This problem is underspecified, e.g., I'm not saying how to represent the month and day. I'm leaving that up to you.

This problem should be as simple as it seems (no input, no application, no error handling). Focus on writing good, solid, well-commented (JavaDocs!), and well-tested code.

The problem doesn't seem like one of my normal problems because it isn't. We're building to something.

Save the output of your program in birthday.out Add that file to your repository. This is a good time to commit and push your code.

Part 3: Updating the Birthday Class

Overriding Methods

Add appropriate toString and equals methods. Make sure you use the appropriate signature for each method, i.e., the same as the parent class's.

You will probably be tempted to have a Birthday object as a parameter to the equals method you're implementing. However, the parameter should be an Object object, to match the parent Object class's method.

Follow the procedure below for implementing the equals method:

  1. Use the == operator to check if the argument is a reference to this object. (If the variables are references to the same object, they're clearly equal!)
  2. Use the instanceof operator to check if the argument has the correct type. (Note: if a variable is a null reference, then instanceof will be false, so we don't need to check if the other object is null separately.)
  3. Cast the argument to the correct type.
  4. For each "significant" field in the class, check if that field of the argument matches the corresponding field of this object. Note: for doubles, use Double.compare and for floats use Float.compare
Source: Effective Java

As always, make sure to test your methods appropriately in the main method.

Overloading Constructors

Add a new constructor for the Birthday class. This constructor takes no parameters and randomly generates the birthday (the month and date).

To create the random birthday, you may need a static, final array of integers representing the number of days in a month. (Why?) For this assignment, assume that February has 29 days. Also, you want only one random number generator object for the whole Birthday class to ensure the best random number generation. (We can debate about whether a uniform distribution is the correct way to generate birthdays, but for simplicity, that is our assumption.) Note that having one random number generator object does not mean that you are only generating one random number. One generator can generate lots of random numbers.

Test by creating at least one object using this constructor and calling some methods on it. (Why would it be beneficial to create more than one object?)

Save the output from all your tests in birthday2.out.

Part 4: Using the Birthday Class to Model the Birthday Paradox

Are you familiar with the birthday paradox? In a group of 23 randomly chosen people, there is more than 50% probability that some pair of them will both have been born on the same day. For 57 people, the probability is more than 99%.

Write a Java class (separate from the Birthday class) that runs an experiment that tests/verifies these probabilities. Name the file BirthdayParadox.java. Since Birthday.java and BirthdayParadox.java are in the same directory, BirthdayParadox.java does not need to import Birthday.

For a set of people with randomly generated birthdays, determine if any of them have the same birthday. Because there is randomness involved, you need to run the experiment several times, each time with a new set of people with randomly generated birthdays. (30 is usually the magic number of experiments, but when you're first testing, you'll want to perform fewer experiments.)

Run the experiment with different numbers of people: from 5 to 100 people, in 5-person increments.

Note that a positive trial means that there was at least one pair of people with the same birthday. There could be more than one pair with the same birthday in a trial, but that only counts as one positive trial.

Stop here. In previous assignments, I broke larger problems down for you into pieces. That changes now.
Start thinking about what methods/functionality would be helpful in implementing the solution. How can you break this problem into smaller, easily testable pieces? If you don't break the problem into small, testable parts, you will undoubtedly struggle because you're trying to do too much at once and you're new to Java.

Print out the results of your experiment in a table, as shown below. Show the number of people, the number of trials, the number of positive trials, and the percent of positive trials.

You can use String.format or the printf method of System.out. (References for Formatter, which talks in detail about the format specifiers; for printf: Colorado State and Baeldung.) Example output:

# People       # Trials         # Positive         Pct
--------       --------         ----------      ------
       5             10                  1        10.0
      10             10                  1        10.0
      15             10                  2        20.0
      20             10                  4        40.0
      25             10                  6        60.0
      30             10                  7        70.0
      35             10                  5        50.0
      40             10                  9        90.0
      45             10                 10       100.0
      50             10                 10       100.0
      55             10                 10       100.0
      60             10                 10       100.0
      65             10                 10       100.0
      70             10                 10       100.0
      75             10                 10       100.0
      80             10                 10       100.0
      85             10                 10       100.0
      90             10                 10       100.0
      95             10                 10       100.0
     100             10                 10       100.0

# People        # Trials        # Positive        Pct
--------        --------        ----------      -----
       5              30                 1        3.3
      10              30                 5       16.7
      15              30                 8       26.7
      20              30                12       40.0
      25              30                17       56.7
      30              30                21       70.0
      35              30                23       76.7
      40              30                27       90.0
      45              30                30      100.0
      50              30                27       90.0
      55              30                30      100.0
      60              30                30      100.0
      65              30                30      100.0
      70              30                30      100.0
      75              30                30      100.0
      80              30                30      100.0
      85              30                30      100.0
      90              30                30      100.0
      95              30                30      100.0
     100              30                30      100.0

In the above table, # Positive is the number of times at least two people had the same birthday out of all the times the experiment was run.

Note: your new Java class should "see" your Birthday class if you used the public keyword before class in Birthday.java and if the two .class files are in the same directory.

Use good program organization, e.g., write methods to make your code easier to read/understand.

Save the output from one run of your program using 30 trials in a file named paradox.out. Add the file to your repository.

Students sometimes get overwhelmed by this problem. It is important that you break it into small steps to make sure that it works, then move on to the next part. Recall good development processes.

Extra Credit (4 pts)

Have your program take as a command-line argument the number of trials to perform. If the command-line argument is not given, default to 30 experiments. You may find Java's Integer class helpful.

Submission

As usual, put all of your code and output files in your GitHub repository that both you and I can access.

Grading (200 pts)

You will be evaluated based on