Genéricos Java

Neste tutorial, vamos aprender sobre Java Generics, como criar classes e métodos genéricos e suas vantagens com a ajuda de exemplos.

O Java Generics nos permite criar uma única classe, interface e método que pode ser usado com diferentes tipos de dados (objetos).

Isso nos ajuda a reutilizar nosso código.

Observação :Genéricos não funciona com tipos primitivos (int , float , char , etc).

Classe de Genéricos Java

Podemos criar uma classe que pode ser usada com qualquer tipo de dado. Essa classe é conhecida como Classe Genérica.

Veja como podemos criar uma classe genérica em Java:

Exemplo:criar uma classe de genéricos

class Main {
  public static void main(String[] args) {

    // initialize generic class
    // with Integer data
    GenericsClass<Integer> intObj = new GenericsClass<>(5);
    System.out.println("Generic Class returns: " + intObj.getData());

    // initialize generic class
    // with String data
    GenericsClass<String> stringObj = new GenericsClass<>("Java Programming");
    System.out.println("Generic Class returns: " + stringObj.getData());
  }
}

// create a generics class
class GenericsClass<T> {

  // variable of T type
  private T data;

  public GenericsClass(T data) {
    this.data = data;
  }

  // method that return T type variable
  public T getData() {
    return this.data;
  }
}

Saída

Generic Class returns: 5
Generic Class returns: Java Programming

No exemplo acima, criamos uma classe genérica chamada GenericsClass . Esta classe pode ser usada para trabalhar com qualquer tipo de dados.

class GenericsClass<T> {...}

Aqui, T usado dentro do colchete angular <> indica o parâmetro de tipo . Dentro do Main class, criamos dois objetos de GenericsClass

intObj - Aqui, o parâmetro de tipo T é substituído por Integer . Agora, a GenericsClass funciona com dados inteiros.
stringObj - Aqui, o parâmetro de tipo T é substituído por String . Agora, a GenericsClass funciona com dados de string.

Método Java Genéricos

Semelhante à classe generics, também podemos criar um método que pode ser usado com qualquer tipo de dado. Essa classe é conhecida como Método Genérico.

Veja como podemos criar uma classe genérica em Java:

Exemplo:criar um método genérico

class Main {
  public static void main(String[] args) {

    // initialize the class with Integer data
    DemoClass demo = new DemoClass();

    // generics method working with String
    demo.<String>genericsMethod("Java Programming");

    // generics method working with integer
    demo.<Integer>genericsMethod(25);
  }
}

class DemoClass {

  // creae a generics method
  public <T> void genericsMethod(T data) {
    System.out.println("Generics Method:");
    System.out.println("Data Passed: " + data);
  }
}

Saída

Generics Method:
Data Passed: Java Programming
Generics Method:
Data Passed: 25

No exemplo acima, criamos um método genérico chamado genericsMethod .

public <T> void genericMethod(T data) {...}

Aqui, o parâmetro de tipo <T> é inserido após o modificador public e antes do tipo de retorno void .

Podemos chamar o método generics colocando o tipo real <String> e <Integer> dentro do colchete antes do nome do método.

demo.<String>genericMethod("Java Programming");

demo.<Integer>genericMethod(25);

Observação :Podemos chamar o método generics sem incluir o parâmetro type. Por exemplo,

demo.genericsMethod("Java Programming");

Nesse caso, o compilador pode corresponder ao parâmetro de tipo com base no valor passado para o método.

Tipos limitados

Em geral, o parâmetro de tipo pode aceitar qualquer tipo de dados (exceto tipos primitivos).

No entanto, se quisermos usar genéricos apenas para alguns tipos específicos (como aceitar dados de tipos numéricos), podemos usar tipos limitados.

No caso de tipos vinculados, usamos o extends palavra-chave. Por exemplo,

<T extends A>

Isso significa T só pode aceitar dados que são subtipos de A .

Exemplo:tipos limitados

class GenericsClass <T extends Number> {

  public void display() {
    System.out.println("This is a bounded type generics class.");
  }
}

class Main {
  public static void main(String[] args) {

    // create an object of GenericsClass
    GenericsClass<String> obj = new GenericsClass<>();
  }
}

No exemplo acima, criamos uma classe chamada GenericsClass. Observe a expressão, observe a expressão

<T extends Number>

Aqui, GenericsClass é criado com tipo limitado. Isso significa GenericsClass só pode trabalhar com tipos de dados que são filhos de Number (Integer , Double , e assim por diante).

No entanto, criamos um objeto da classe generics com String . Neste caso, teremos o seguinte erro.

GenericsClass<String> obj = new GenericsClass<>();
                                                 ^
    reason: inference variable T has incompatible bounds
      equality constraints: String
      lower bounds: Number
  where T is a type-variable:
    T extends Number declared in class GenericsClass

Vantagens do Java Generics

1. Reutilização de código

Com a ajuda de genéricos em Java, podemos escrever código que funcionará com diferentes tipos de dados. Por exemplo,

public <T> void genericsMethod(T data) {...}

Aqui, criamos um método genérico. Esse mesmo método pode ser usado para realizar operações em dados inteiros, dados de string e assim por diante.

2. Verificação de tipo em tempo de compilação

O parâmetro de tipo de genéricos fornece informações sobre o tipo de dados usados no código de genéricos. Por exemplo,

// using Generics
GenericsClass<Integer> list = new GenericsClass<>();

Aqui, sabemos que GenericsClass está trabalhando com Integer apenas dados.

Agora, se tentarmos passar dados diferentes de Integer para essa classe, o programa gerará um erro em tempo de compilação.

3. Usado com coleções

A estrutura de coleções usa o conceito de genéricos em Java. Por exemplo,

// creating a string type ArrayList
ArrayList<String> list1 = new ArrayList<>();

// creating a integer type ArrayList
ArrayList<Integer> list2 = new ArrayList<>();

No exemplo acima, usamos a mesma classe ArrayList para trabalhar com diferentes tipos de dados.

Semelhante a ArrayList , outras coleções (LinkedList , Queue , Maps , e assim por diante) também são genéricos em Java.

Expressões Java Lambda Classe de arquivo Java

Java