Question

Write a static method named checkOrder that is parameterized by a bounded generic type T that extends Comparable. The method should take four formal parameters: t1, t2, t3, and t4 each of type T. The method should return an int containing:

-1 if the parameters t1, t2, t3, and t4 are in ascending order,

1 if all parameters are in descending order and,

0 if the parameters are unordered.

Hint: since the type variable T is 'bounded' by Comparable you can call compareTo(..) on variables of type T. For example, t1.compareTo(t2) < 0, etc. Review the compareTo method contract if needed (you can find it in the Comparable interface).

To test your solution to ensure it works, paste the following test code into your main() method:

System.out.println(checkOrder("a", "d", "b", "g")); // should print 0
System.out.println(checkOrder(2.3, 3.4, 4.5, 5.6)); // should print -1
System.out.println(checkOrder(5, 3, 2, 1)); // should print 1
System.out.println(checkOrder('c', 'd', 'h', 'i')); // should print -1
System.out.println(checkOrder('c', 'd', 'h', 'a')); // should print 0
System.out.println(checkOrder(
Year.of(2002), Year.of(2001), Year.of(2000), Year.of(1990))); // should print 1

Answer 1

```java

public static <T extends Comparable<T>> int checkOrder(T t1, T t2, T t3, T t4) {

if (t1.compareTo(t2) < 0 && t2.compareTo(t3) < 0 && t3.compareTo(t4) < 0) {

return -1; // Ascending order

} else if (t1.compareTo(t2) > 0 && t2.compareTo(t3) > 0 && t3.compareTo(t4) > 0) {

return 1; // Descending order

} else {

return 0; // Unordered

}

}

```

Step-by-step explanation:

The provided static method, `checkOrder`, takes four parameters of type T, where T is a bounded generic type extending Comparable. The method utilizes the compareTo method, inherent to the Comparable interface, to compare the relationships between the parameters. For ascending order, it checks if each subsequent element is greater than its predecessor. For descending order, it checks the reverse. The method returns -1 for ascending order, 1 for descending order, and 0 for unordered.

To elaborate, the comparison uses the compareTo method's result, which returns a negative value if the invoking object is less than the argument, zero if equal, and a positive value if greater. The logical combinations ensure that the method accurately identifies the order relationship between the parameters. The generic nature of the method allows it to handle various data types, ensuring flexibility and reusability.

The provided test code demonstrates the functionality of the `checkOrder` method with different data types, confirming its ability to correctly determine the order relationship between the parameters, be it ascending, descending, or unordered. This implementation aligns with best practices in Java generics and leverages the Comparable interface for effective comparison.