Solucionado (ver solução)
Solucionado
(ver solução)
1
resposta

[Dúvida] Uso de Generis

Seria correto usar Generics ao invés da classe Object como parâmeto como visto abaixo?

 public static <T> HttpResponse<String> dispararRequisicaoPost( String uri, T json) throws IOException, InterruptedException {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(uri))
                .header("Content-Type", "application/json")
                .method("POST", HttpRequest.BodyPublishers.ofString(new Gson().toJson(json)))
                .build();

        return client.send(request, HttpResponse.BodyHandlers.ofString());
    }
1 resposta
solução!

Nesse caso você poderia utilizar Object mesmo, sobre o uso de Generics:

Imagina que queremos uma função que recebe um vetor de números e retorna o maior elemento, mas precisamos usar essa função também para encontrar o maior elemento de um vetor de char

//função que recebe vetor de números
public static int maior(int[] array) {
    int maior = array[0];
    for (int item : array) {
        if (item > maior) {
            maior = item;
        }
    }
    return maior;
}

public static void main(String[] args) {
    char[] caracteres = {'y', 'm', 'a', 'q'};
    char maiorChar = maior(caracteres); // ERRO: tipos incompatíveis
    System.out.println("O maior caractere é " + maiorChar);
}

Essa operação resulta em erro, os são tipos incompatíveis, a função espera vetor de números, não um vetor de char...

Para resolver o problema você cria uma outra função que recebe um vetor de char e retorna o maior elemento:

//função que recebe vetor de números
public static int maior(int[] array) {
    int maior = array[0];
    for (int item : array) {
        if (item > maior) {
            maior = item;
        }
    }
    return maior;
}

//função que recebe vetor de char
public static char maior(char[] array) {
    char maior = array[0];
    for (char item : array) {
        if (item > maior) {
            maior = item;
        }
    }
    return maior;
}

public static void main(String[] args) {
    int[] numeros = {34, 50, 25, 100, 65};
    int maiorNumero = maior(numeros);
    System.out.println("O maior número é " + maiorNumero);

    char[] caracteres = {'y', 'm', 'a', 'q'};
    char maiorCaractere = maior(caracteres);
    System.out.println("O maior caractere é " + maiorCaractere);
}

O problema foi resolvido, mas temos agora 2 funções com o mesmo nome e que fazem a mesma coisa, mas que recebem dados diferentes, uma forma de evitar essa duplicidade seria usando generics

public static <T extends Comparable<T>> T maior(T[] array) {
    if (array == null || array.length == 0) {
        throw new IllegalArgumentException("O array não pode ser nulo ou vazio");
    }

    T maior = array[0];
    for (T item : array) {
        if (item.compareTo(maior) > 0) {
            maior = item;
        }
    }
    return maior;
}

public static void main(String[] args) {
    Integer[] numeros = {34, 50, 25, 100, 65};
    Integer maiorNumero = maior(numeros);
    System.out.println("O maior número é " + maiorNumero);

    Character[] caracteres = {'y', 'm', 'a', 'q'};
    Character maiorCaractere = maior(caracteres);
    System.out.println("O maior caractere é " + maiorCaractere);
}

Dessa forma você teria apenas uma função que realiza a mesma operação em cima de TIPOS de variáveis diferentes