The learning objective of this question is to illustrate the power of Java inheritance and polymorphism. Your response to this question is in multiple parts. You will submit your answers as specified at the end of this question.
To help you get started and to guide your development efforts for this assignment we have provided scaffolding code. Download and unzip the BlueJ project count.zip. Study the code along with the description below. Edit the code and submit the completed BlueJ project. We have also provided a unit test file to help you check your code.
Now, let us look at the question.
Consider an array of integers as below:
int[] a = {5, 2, -4, 3, 0, -5, 7, 11, 6, 13}
Complete the method named count(int[] a) in the class Count. The method should return the number of positive numbers in the array. Thus count(a)should return 7 (not counting the 2 negative numbers and 0).
On examining your code for count (your solution to part-a), you will see a test similar to this: if (a[i]>0) {...}. If we were to now ask you to modify thecount method so that it counted the number of negative numbers, it would be trivial: All that you would have to do is change the greater-than comparison operator (">")to the less-than operator ("<"). If we were to ask you to modify the count method to count the number of even numbers (whether positive or negative) then you would modify your code to have a test along the following lines: if (isEven(a[i])) {...}. Similarly, you could change your code for other types of counting (prime numbers, numbers greater than 10, etc). Note that in each case we can do any type of counting we like but we need to edit the code for thecount method. This is a simple example of enhancing the functionality of existing code. For this part of the question, you will write Java code that allows you to enhance the counting functionality without modifying the code of existing methods. You will do this using the power of inheritance and polymorphism.
Complete the method countIF that is similar to your implementation of count (from the earlier part of this question) but takes as parameter an object that implements the appropriate test. The signature of countIF is as below:
int countIF( int[] a, Predicate p)
Complete the class Predicate which has just one method that returns true if the parameter is greater than 0:
boolean test(int x){ ... ? ... }
When countIF is invoked with a Predicate object, the behaviour will be as before: Your code will count the number of integers greater than 0 (i.e., the execution would return 7).
Now complete the two classes (IsNegative and IsEven) as subclasses of the Predicate class to help you count negative (IsNegative) and even numbers (IsEven).
class IsNegative extends Predicate {...}
class IsEven extends Predicate {...}
Note: IsNegative and IsEven classes should have a test method with the same signature as before: boolean test(int x). Once these classes have been written you will be able to pass in an instance of the appropriate class to countIF to do the testing we need:
countIF( a, new IsNegative() )
countIF( a, new IsEven() )
The first call above would return 2 for our array. The second call would return 4.
After completing and testing your solution, zip the entire BlueJ folder and submit it. Since your instructor will need all files in the project folder, make sure you zip the entire folder. For this question the names of the BlueJ project, Java class files, and the zip file you submit are given below:
BlueJ project: count
Java classes and Interfaces:
Count.java (this will have two methods: count, and countIF)
Predicate.java (a Java class with one method test)
IsNegative.java (extends Predicate)
IsEven.java (extends Predicate)
CountTest.java (the unit test file - This file is fully complete. Do not modify this file.)
Submit: count.zip