A02

Due Date: Friday, 22 January 2021
File(s) to be submitted: PovertyData.java
Sample Output: SampleOutput.html

Poverty Data (imperative programming including methods and arrays)

Summary

Your task is to create a program class that reads some income data then prints a report on poverty rates.

Your program uses an array to keep track of the incomes of multiple families. It also uses various methods to calculate statistics for those families.

For an introduction to measuring poverty, see the Wikipedia page.

Watch a video about this assignment on YouTube. Or get it from the course website.

Details

1. Your program starts by printing out a program identification and self-description, and then pauses.

   Poverty Rate Program
   --------------------
   
   This program reads data on family incomes and produces a report on poverty
   rates among the families.  
   
   By Mark Young (A00000000)
   Winter, 2021
   
   ...press enter...
   

2. Your program then asks the user to enter family income data.

   How many families are there in this country? 5
   
   What is the income for family #1? 5000
   What is the income for family #2? 15000
   What is the income for family #3? 35000
   What is the income for family #4? 55000
   What is the income for family #5? 95000
   

   There must be at least two families in the country, and each income must be non-negative (that is, zero is allowed as an income). If invalid data is entered, the program requests a replacement.
3. Next your program reads the "basic needs income" -- the amount of income that's required to cover their basic needs -- that is, to keep them out of absolute poverty.

   What is the minimum income required to support a family? 10000
   

   Once again, the income must be non-negative. If invalid data is entered, the method requests a replacement.
4. The program then pauses, asking the user to press the enter key.
5. After the user presses the enter key, the program prints its report.

   Report
   ------
   
   Average Income:        $41000.0
   Basic Needs Income:    $10000.0
   Absolute Poverty Rate:  20.0%
   
   Median Income:         $35000.0
   Relative Needs Income: $21000.0
   Relative Poverty Rate:  40.0%
   

   The report has a title and two sections.

   The first section is for the absolute poverty rate. It shows the average income for the families, the basic needs income, and the percent of families with income less than the basic needs income. (In this example only family #1 had an income less than $10000, and so the absolute poverty rate is 1 in 5, or 20%.)

   The second section is for the relative poverty rate. It shows the median income for the families, the relative needs income, and the percent of families with income less than the relative needs income. (In this example two families has less than $21000 income, so the relative poverty rate is 2 in 5, or 40%.)

6. After printing the report, the program pauses again, prompting the user to press the enter key. The program ends after the user presses the enter key.

Your program uses methods as follows:

• A method to print the program introduction.
• A method to pause.
• A method to read the array of incomes.
• A method to read a non-negative income.
• A method to print the report.
• A method to calculate the average income.
• A method to calculate the median income.
• A method to calculate what percent of the families fall below a given income.

Some methods will be called more than once.

Each method must be given all the information it needs to do its job. (For example, the method to calculate the average income needs to be given the array containing all the incomes.) Methods for calculating must return the calculated values, not print them.

Notes

• Your main program should be very short -- three to seven lines of code (blank lines and comments not counted).
• You may use a class constant for the Scanner -- it will be used by multiple methods, and it's a pain to pass it around.

  You also need to make appropriate use of program constants in your program. No magic numbers, please!

  You are not allowed to use any other static variables.

• The average of a list is the sum of all its elements divided by the number of elements. In the example above, the sum is 5000 + 15000 + 35000 + 55000 + 95000 = 205000. There are five values, so the average is 205000/5 = 41000.
• The median of a list is the value right in the middle of the sorted list. (Hint: you can sort an array using java.utils.Arrays' sort method.) For an array with an odd number of elements, you can just divide its length by 2 and use that index. In the example above, there are five elements in the sorted list, and so we use the value in location 5/2 = 2, which is 35000. (Remember that the first element of an array is in location zero, so the element in location 2 is in the very middle of the five element array.)

  The median of a list with an even number of elements is only a little bit harder. It's the average of the two elements in the middle. So, for example, if we'd used only the first four of the families above, the median would be the average of 15000 and 35000, which is 25000. Divide the length of the array by 2, and use that index and the one before it. So for an arry of length 4, we use locations 4/2 = 2 and 2-1 = 1 -- 35000 and 15000.

• The relative needs income is 60% of the median income.
• You must error-check the user's input. Remember how we use a sentinel-controlled loop to ensure that a value is in the appropriate range. That is:
  1. Ask for and read a value.
  2. While the value is inappropriate:
     1. Report the appropriate range.
     2. Ask for and read a replacement value.

  You should not be using conditional controls in this part of the program.

Grading Outline

• Files with the wrong name will be penalized 10 points.
• Code that does not compile will be penalized 10 points plus 5 points for each line that needs to be fixed.
• Up to 30 points may be deducted for code that does not meet the standard requirements described in the rules for submissions and the style rules.
• Up to 30 points may be deducted for code that does not follow the design described above and the general good design principles.
• Up to 100 points may be deducted for code that does not perform properly.