Arrays. sort () 방법 에 사용 되 는 디자인 모델

    /**
     * Src is the source array that starts at index 0
     * Dest is the (possibly larger) array destination with a possible offset
     * low is the index in dest to start sorting
     * high is the end index in dest to end sorting
     * off is the offset to generate corresponding low, high in src
     */
    private static void mergeSort(Object[] src,
				  Object[] dest,
				  int low,
				  int high,
				  int off) {
	int length = high - low;

	// Insertion sort on smallest arrays
        if (length < INSERTIONSORT_THRESHOLD) {
            for (int i=low; ilow &&
			 ((Comparable) dest[j-1]).compareTo(dest[j])>0; j--)
                    swap(dest, j, j-1);
            return;
        }

        // Recursively sort halves of dest into src
        int destLow  = low;
        int destHigh = high;
        low  += off;
        high += off;
        int mid = (low + high) >>> 1;
        mergeSort(dest, src, low, mid, -off);
        mergeSort(dest, src, mid, high, -off);

        // If list is already sorted, just copy from src to dest.  This is an
        // optimization that results in faster sorts for nearly ordered lists.
        if (((Comparable)src[mid-1]).compareTo(src[mid]) <= 0) {
            System.arraycopy(src, low, dest, destLow, length);
            return;
        }

        // Merge sorted halves (now in src) into dest
        for(int i = destLow, p = low, q = mid; i < destHigh; i++) {
            if (q >= high || p < mid && ((Comparable)src[p]).compareTo(src[q])<=0)
                dest[i] = src[p++];
            else
                dest[i] = src[q++];
        }
    }

 
When we use the Arrays.sort(Object[] objects) static method to sort array of objects, we may find that it requires that the elements of the array implement the Comparable interface, as they need to be comparable to each other, it's the prerequisite. but how is it able to fulfil this? how does know whether the self-defined Object class has implemented the Comparable? we know actually it's the template pattern although it does extend something, but it's template, it implements something instread so that the algorithms defined in the sort method has been filled out or completed.
Yes, turn to the question about how does it know? after test, i get know that it solves this question by falling it into the Runtime Exception just like it displays that:
 
Exception in thread "main" java.lang.ClassCastException: MyString cannot be cast to java.lang.Comparable     at java.util.Arrays.mergeSort(Unknown Source)     at java.util.Arrays.sort(Unknown Source)     at Test.main(Test.java:14)
 

import java.util.Arrays;

public class Test {

	public static void main(String[] args) {
		MyString[] strings = {new MyString(2), new MyString(1)};
		Arrays.sort(strings);
		System.out.println(strings[0]);
	}

}

class MyString {
	int x;
	public MyString(int x) {
		this.x = x;
	}
}

 
the fact happens that sort is the helper method and mergeSort locates at the body of the sort method.