Seção 19: Generics, Set, Map

JayCesar commented 1 year ago

📍Generics

Generics permitem que classes, interfaces e métodos possam ser parametrizados por tipo, Seus benefícios são:

Reuso
Type safety;
Performance;
Uso comum: coleções

List<String> list = new ArrayList<>();
list.add("Maria");
String name = list.age(0);

2023-07-08_10h54_09

2023-07-08_10h55_48

Supomos que ao invés de números, eu queira utilizar nomes! ou seja, "Strings", logo não seria possível!

Seu deixar a List com o tipo "Object"

List<Object> list = new ArrayList<>();

Quando eu foi querer adicionar um dos valores dela para uma variável do tipo integer, eu terei que fazer um casting (converter):

Integer x = (Integer) ps.first(); // Eu vou ter que converter

Logo eu terei um problema de segurança de tipos → TypeSafety e também de Performance.

É aqui que entra os Generics: 2023-07-08_11h21_14

public class PrintService<T> {

    List<T> list = new ArrayList<>();

    public void addValue(T value) {
        list.add(value);
    }
}

⚠️Se eu instanciar um PrintService do tipo String, ele só irá aceitar String, se for Inteiro, será só Inteiro e etc..

Quando eu for instanciar no programa principal, eu preciso indicar o tipo:

PrintService<Integer> ps = new PrintService<>();
// Repare que é preciso colocar '<>' no final antes dos parêntreses para dizer pro compilador que é um Generics;

// Seu quiser adicionar um tipo String eu não irei conseguir:

ps.addValue("Maria"); // O compilador irá reclamar

Classe Service:

// Agora minha classe está parametrizada com um certo tipo "T";
public class PrintService<T> {

    List<T> list = new ArrayList<>();

    public void addValue(T value) {
        list.add(value);
    }

    public T first() {
        if (list.isEmpty()) {
            throw new IllegalStateException("List is empty"); // Programação defensiva
        }
        return list.get(0);
    }

    public void print() {
        System.out.print("[");
        if (!list.isEmpty()) {
            System.out.print(list.get(0));
        }
        for(int i = 1; i < list.size(); i++) {
            System.out.print(", " + list.get(i));
        }
        System.out.println("]");
    }
}

Programa principal:

package application;

import java.util.Scanner;

import services.PrintService;

public class Program {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        PrintService<Integer> ps = new PrintService<>();

        System.out.println("How many values? ");
        int n = sc.nextInt();

        for (int i = 0; i < n; i++) {
            Integer value = sc.nextInt();
            ps.addValue(value);
        }

        ps.print();
        Integer x = ps.first(); 
        System.out.println("First: " + x);

        sc.close();

    }
}

JayCesar commented 1 year ago

Genéricos delimitados

2023-07-08_11h46_25

O jeito mais completo de implementação é esse:

2023-07-08_12h22_42

public static <T extends Comparable<? super T>> T max(List<T> list)

É um tipo comparável T, ou qualquer super classe de T! Pode ser o Produto ou qualquer Super classe do Produto! Porque se alguma super classe do Produto possuir o CompareTo, o produto irá herdar esse compareTo

JayCesar commented 1 year ago