Code review

public boolean isPresent() {
    return object != null;
}

public class Obscure<T> {
    private T object;

    public Obscure(T object) {
        this.object = object;
    }

public class Obscure<T> {
    private T value;

    public Obscure(T value) {
        this.value = value;
    }

public T orElseThrow(Exception e) throws Exception {
    if (isPresent()) {
        return object;
    } else {
        throw e;
    }
}

public class Obscure<T, E extends Exception> {
    public T orElseThrow(E e) throws E {
        if (isPresent()) {
            return object;
        } else {
            throw e;
        }
    }

public static <T> Obscure of(T object) {
    return new Obscure<>(object);
}

public static <T> Obscure empty() {
    return new Obscure<>(null);
}

public static <T> Obscure<T> of(T object) {
    return new Obscure<>(object);
}

public static <T> Obscure<T> empty() {
    return new Obscure<>(null);
}

public abstract class Math<T extends Number> {
    public static <T> T getMaxValueOfThree(T first, T second, T third) {
        T[] array = (T[]) new Object[]{first, second, third};
        return getMaxValueArray(array);
    }

public abstract class Math {
    public static <T extends Number> Number getMaxValueOfThree(T first, T second, T third) {
        Number[] array = new Number[]{first, second, third};
        return getMaxValueArray(array);
    }

public class MathTests {
    static Stream<Arguments> provideArgumentsGetMaxValueArray() {
        return Stream.of(
                Arguments.of(new Integer[]{1, 2, 3}, 3),
                Arguments.of(new Integer[]{3, 1, 5, 7}, 7),
                Arguments.of(new Integer[]{6, 2}, 6)
        );
    }
    @ParameterizedTest
    @MethodSource("provideArgumentsGetMaxValueArray")
    void testGetMaxValueArray(Integer[] array, int expected) {
        int actual = Math.getMaxValueArray(array);

        assertEquals(expected, actual);
    }

public static <K extends Number> K getMax(K ... numbers) {
    // code
}

@ParameterizedTest
@MethodSource("orElseThrowProviderArguments")
void orElseThrowTest(T obscure, String expectedResult) {
    Obscure<T> obscure1 = new Obscure<>(obscure);
    String actualResult;
    try {
        actualResult = (String) obscure1.orElseThrow(new Exception("This is NullPointerException"));
    } catch (Exception ex) {
        actualResult = ex.getMessage();
    }
    Assertions.assertEquals(actualResult, expectedResult);
}

public static Number getMaxValueInArray(Number[] array) {
    sort(array);
    Number result = array[array.length - 1];
    return result;
}

public class Pair<K, V> {
    private K field1;
    private V field2;

    ...
}

public T orElseThrow() {
    if (element != null) {
        return element;
    } else {
        throw new NullPointerException("This is NullPointException!");
    }
}

public class PairDemo {
    public static void main(String[] args) {
        Pair<Integer, Integer> pair = new Pair<>(50,60);
        System.out.printf("%s %s \n", pair.getK(), pair.getV());

        Pair pair1 = pair.getSwapped();
        System.out.printf("%s %s \n", pair1.getK(), pair1.getV());
    }
}

public abstract class Math<T> {

    public static <T> int findMaximum(int value1, int value2, int value3) {
        if (value1 > value2 && value1 > value3) {
            return value1;
        } else if (value2 > value1 && value2 > value3) {
            return value2;
        } else {
            return value3;
        }
    }

    ...
}