Write a full program containing a method countValidNumbers

according to the following description. Please review this

information carefully, including the grading rubric at the

end; take notes as you plan your program to make sure

you cover all of the requirements:

Write a method that counts valid numbers entered by the user.

The method takes a Scanner$170$ connected to the console plus

two ints as its parameters $-$ only numbers that are evenly

divisible by a number between those two ints, inclusive, are$$

considered valid, so if the ints are $4$ and $7$ then numbers that$$

are evenly divisible by $4,5,6,$ or $7$ are considered valid

numbers and should be counted. Numbers that are not evenly

divisible by any of the indicated numbers are not counted.

This is a conditional cumulative sum problem. Be careful: if

a number is evenly divisible by more than one of the ints in

the parameter range, you must only count that valid number once.

The method must reject second and$/$or third parameter values

that are $<=0$ by throwing an IllegalArgumentException.

The two integers given to the method may be given in either

order, the smaller first or the larger. You may want to write$$

code inside the method to check their order so that you always$$

process the integers from the smaller to the larger. The two$$

integers may be the same.$$

Note that if one of the parameter numbers has the value $1$ then$$

any number that the user enters will be valid.

After the method counts valid numbers that the user enters it

must return that count. The user signals that all numbers have

been entered by typing anything that is not a number. Use

Scanner$170$ methods to check whether the next thing to be

read is in fact a number, and stop counting if it is not. Be sure

to "consume" that non$-$number by reading it as a "word" so that

future calls of countValidNumbers will be able to work. Note

that the user may type each number on a separate line or type

some or all of the numbers on the same line separated by

white space $($each number is a Scanner$170$ "token"$).$

The method must tell the user what it does and prompt them

for input related to the numeric parameters it is given. The

method must tell the user that when they enter something that

is not a number the program will stop accepting numbers and

return the count of valid user numbers that it has seen so far.

The ending non$-$number must not be included in the count, it

is a SENTINEL value for the method.

The program must contain both pseudocode for the method as

well as pre$-$ and post$-$condition comments regarding the method.

Note: pseudocode is not in$-$line comments inside the method,

but rather a block of comments before the method that explains

how the method will implement its requirements conceptually, not

with details about the implementation $-$ so the pseudocode would

NOT look like Java statements but rather what logic and

information it will use in its implementation. It may include

the types of statements used in the method such as loops or

decision$-$making, but only the general nature of those statements

and the tests that such statements use, not their specific content.

See pages $108-109,180-182,$ and $259$ in the textbook.

Pre$-$ and post$-$condition comments must follow the pseudocode and

precede the method. See pages $279-283$ and $372$ in the textbook.

The method may optionally contain in$-$line comments as well.

Note that it is permissible to have additional "helper" methods

that make writing the required method easier. If you write such

methods you must also write pseudocode and pre$-$ and post$-$

condition comments for those methods.

The program containing this method must call$/$test the method

in main three $(3)$ times for testing purposes as follows:

Test $1$: the numbers are $2$ and $5,$ in that order

Test $2$: the numbers are $7$ and $4,$ in that order

Test $3$: at least one of the numbers is $<=0($throws an exception$)$

At least one of the numbers entered for the first test should

not be divisible by any of $2,3,4,$ or $5$; for the second test

the first entered number should be invalid $($not divisible by $4,$

$5,6,$ or $7,$ like $13)$ and the second entered "number" should be

some random non$-$number, like STOP, so that the returned count

of valid user numbers would be $0.$ The third test should throw$$

the required exception because at least one of the int parameter

values is $<=0.$

Example:

If the method is called like this:

$$int count $=$ countValidNumbers$($console$,2,5)$;

and the user types the following lines:

$7$

$13$

$29$

$221311589$

$//$endOfInput

then the method will return a count of $3$ valid numbers, $2$

$($divisible by $2),21($divisible by $3),$ and $15($divisible by

$3$ and $5,$ only counted once$)-$ the other numbers are primes,

so $2,3,4,$ and $5$ do not divide them evenly.