Binary search on a Bitonic array
maxPossibleValue seems to be an instance-independent constant and should therefore be static and final (and, as such, should conventionally be in uppercase letters with words being separated by an underscore character, i.e. MAX_POSSIBLE_VALUE).
array[i] = (int)Math.floor(Math.random() * maxPossibleValue);


The problem with this line is that the array will never contain maxPossibleValue itself, because the value returned by Math.random() will always be less than, but never equal to 1.0. Besides, there is a simpler way of accomplishing what you want: Instead of using Math.random(), use an instance of Random:

Random randomGenerator = new Random();
for(int i = 0; i &lt; n; i++){
    array[i] = randomGenerator.nextInt(maxPossibleValue + 1);
}

Your method of sorting the array doesn't work correctly. First of all, the integer at the index inv will never be modified, because your first sort only sorts the indexes 0 to inv - 1 and the second sort sorts the indexes inv + 1 to n - 1 (the end index passed to the sort method is exclusive).

But even if you corrected this issue, the problem remains that you still don't know which of the two adjacent indices contains the greater integer. For example, when you have the array {1,2,3,4,5} and define 2 as the inversion point index (i.e. the third number in the array), and sort the first three numbers and the last two numbers separately, then you will get {1,2,3,5,4}, meaning the inversion point will be 3 instead of 2. If you really want to ensure that the number at the inversion point will be the largest number in the array, I don't think you will get around doing that manually, i.e. finding the largest number in the array and moving it to the inversion point by swapping it with the number previously there.
The constructor Bitonic(int, int) does not check whether the passed arguments are valid. If it did, you would not need to use expressions like Math.min(inv + 1, n) when you sort the numbers on the right side of the inversion point (regardless of the fact that the sorting algorithm does not work correctly, as I previously pointed out).
int currentPoint = (int)Math.floor(end + start)/2;


There are several problems with this line. First, you probably forgot a pair of parentheses around the expression (end + start)/2. But even so, wrapping (end + start)/2 in Math.floor(double) is pointless, because (end + start)/2 already returns an integer (see here).

Finally, you are risking an integer overflow with end + start. A way to prevent this would be to write start + (end - start)/2 instead (this is only guaranteed not to overflow if end &gt;= start).
This:

if(currentValue &lt; target){
    return finder(target, right, end);
}
else{
    int result = finder(target, start, left);
    if(result != -1){
        return result;
    }
    return finder(target, right, end);
}


can be written more concisely as:

int result;
if (currentValue &gt;= target
        &amp;&amp; (result = finder(target, start, left)) != -1) {
    return result;
} else {
    return finder(target, right, end);
}


The same goes for the analogous code when currentValue lies after the inversion point.


Update


Another thing just occurred to me: You can save unnecessary recursive calls if you changed the conditions of your two if blocks for being before and after the inversion point to allow one (but not both) of the two adjacent values to be equal to the current value. For example, if you are looking for the number 5 in the array {0,5,4,4,3,2,1}, and currentPoint == 3, so that leftValue == 4, currentValue == 4 and rightValue == 3, your program would enter the final else block and pointlessly search the numbers to the right of currentPoint.

So instead, you could change the conditions to something like this:

if(leftValue &lt;= currentValue
        &amp;&amp; currentValue &lt;= rightValue
        &amp;&amp; leftValue != rightValue)