O que é legal sobre os genéricos, por que usá-los?

Pensei em oferecer este softball para quem quisesse jogar fora do parque. O que são genéricos, quais são as vantagens dos genéricos, por que, onde, como devo usá-los? Por favor, mantenha-o bem básico. Obrigado.

• Permite que você escreva código / use métodos de biblioteca que são seguros para tipos, ou seja, um List <string> é garantidamente uma lista de strings.
• Como resultado do uso de genéricos, o compilador pode realizar verificações de tempo de compilação no código para segurança de tipo, ou seja, você está tentando colocar um int nessa lista de strings? Usar um ArrayList faria com que fosse um erro de tempo de execução menos transparente.
• Mais rápido do que usar objetos, pois evita boxing / unboxing (onde .net tem que converter tipos de valor em tipos de referência ou vice-versa ) ou conversão de objetos para o tipo de referência necessário.
• Permite que você escreva um código que é aplicável a muitos tipos com o mesmo comportamento subjacente, ou seja, um Dicionário <string, int> usa o mesmo código subjacente que um Dicionário <DateTime, double>; usando genéricos, a equipe do framework precisava escrever apenas um trecho de código para obter os dois resultados com as vantagens mencionadas.

Eu realmente odeio me repetir. Eu odeio digitar a mesma coisa com mais frequência do que o necessário. Não gosto de repetir as coisas várias vezes com pequenas diferenças.

Em vez de criar:

class MyObjectList  {
   MyObject get(int index) {...}
}
class MyOtherObjectList  {
   MyOtherObject get(int index) {...}
}
class AnotherObjectList  {
   AnotherObject get(int index) {...}
}

Posso construir uma classe reutilizável ... (no caso de você não querer usar a coleção bruta por algum motivo)

class MyList<T> {
   T get(int index) { ... }
}

Agora estou 3x mais eficiente e só preciso manter uma cópia. Por que você NÃO deseja manter menos código?

Isso também é verdadeiro para classes que não são de coleção, como a Callable<T>ou a, Reference<T>que precisam interagir com outras classes. Você realmente deseja estender Callable<T>e Future<T>todas as outras classes associadas para criar versões de tipo seguro?

Eu não.

Não precisar fazer o typecast é uma das maiores vantagens dos genéricos Java , pois ele executa a verificação de tipo em tempo de compilação. Isso reduzirá a possibilidade de ClassCastExceptions que podem ser lançados no tempo de execução e podem levar a um código mais robusto.

Mas suspeito que você esteja totalmente ciente disso.

Cada vez que vejo os Genéricos, fico com dor de cabeça. Acho que a melhor parte do Java é sua simplicidade e sintaxe mínima e genéricos não são simples e adicionam uma quantidade significativa de nova sintaxe.

No início, também não vi o benefício dos genéricos. Comecei a aprender Java a partir da sintaxe 1.4 (embora Java 5 estivesse lançado na época) e quando encontrei genéricos, senti que era mais código para escrever e realmente não entendi os benefícios.

IDEs modernos facilitam a escrita de código com genéricos.

A maioria dos IDEs modernos e decentes são inteligentes o suficiente para ajudar a escrever código com genéricos, especialmente com o auto-completar de código.

Aqui está um exemplo de como fazer um Map<String, Integer>com a HashMap. O código que eu teria que digitar é:

Map<String, Integer> m = new HashMap<String, Integer>();

E, de fato, é muito digitar apenas para fazer um novo HashMap. No entanto, na realidade, eu só tive que digitar isso antes que o Eclipse soubesse o que eu precisava:

Map<String, Integer> m = new Ha Ctrl+Space

Verdade, eu precisava selecionar HashMapem uma lista de candidatos, mas basicamente o IDE sabia o que adicionar, incluindo os tipos genéricos. Com as ferramentas certas, usar genéricos não é tão ruim.

Além disso, como os tipos são conhecidos, ao recuperar elementos da coleção genérica, o IDE agirá como se aquele objeto já fosse um objeto de seu tipo declarado - não há necessidade de cast para o IDE saber qual o tipo do objeto é.

Uma vantagem importante dos genéricos vem da maneira como ele funciona bem com os novos recursos do Java 5. Aqui está um exemplo de como jogar números inteiros em a Sete calcular seu total:

Set<Integer> set = new HashSet<Integer>();
set.add(10);
set.add(42);

int total = 0;
for (int i : set) {
  total += i;
}

Nesse trecho de código, há três novos recursos Java 5 presentes:

• Genéricos
• Autoboxing e unboxing
• For-each loop

Primeiro, os genéricos e autoboxing de primitivos permitem as seguintes linhas:

set.add(10);
set.add(42);

O inteiro 10é autoboxed em um Integercom o valor de 10. (E o mesmo para 42). Então isso Integeré jogado no Setque é conhecido por conter Integers. Tentar lançar um Stringcausaria um erro de compilação.

Em seguida, o loop for for each leva todos os três:

for (int i : set) {
  total += i;
}

Primeiro, os Setcontendo Integers são usados ​​em um loop for-each. Cada elemento é declarado como um inte isso é permitido quando o Integeré desempacotado de volta para o primitivo int. E o fato de que esse desembalagem ocorre é conhecido porque genéricos foram usados ​​para especificar que havia Integers retidos no Set.

Os genéricos podem ser a cola que reúne os novos recursos introduzidos no Java 5 e simplesmente tornam a codificação mais simples e segura. E na maioria das vezes os IDEs são inteligentes o suficiente para ajudá-lo com boas sugestões, então geralmente, não será muito mais difícil digitar.

E, francamente, como pode ser visto no Setexemplo, acho que utilizar os recursos do Java 5 pode tornar o código mais conciso e robusto.

Editar - Um exemplo sem genéricos

A seguir está uma ilustração do Setexemplo acima sem o uso de genéricos. É possível, mas não é exatamente agradável:

Set set = new HashSet();
set.add(10);
set.add(42);

int total = 0;
for (Object o : set) {
  total += (Integer)o;
}

(Observação: o código acima irá gerar um aviso de conversão não verificada em tempo de compilação.)

Ao usar coleções não genéricas, os tipos inseridos na coleção são objetos do tipo Object. Portanto, neste exemplo, a Objecté o que está sendo addinserido no conjunto.

set.add(10);
set.add(42);

Nas linhas acima, o autoboxing está em jogo - o intvalor primitivo 10e 42está sendo autoboxing em Integerobjetos, que estão sendo adicionados ao Set. No entanto, lembre-se de que os Integerobjetos estão sendo tratados como Objects, pois não há informações de tipo para ajudar o compilador a saber que tipo ele Setdeve esperar.

for (Object o : set) {

Essa é a parte crucial. O motivo pelo qual o loop for-each funciona é porque o Setimplementa a Iterableinterface, que retorna uma Iteratorinformação do tipo with, se presente. ( Iterator<T>isto é.)

No entanto, uma vez que não existe informação de tipo, o Setretornará uma Iteratorque irá retornar os valores no Setcomo Objects, e é por isso que o elemento a ser recuperado na para-cada ciclo tem de ser do tipo Object.

Agora que o Objectfoi recuperado de Set, ele precisa ser convertido em um Integermanualmente para realizar a adição:

  total += (Integer)o;

Aqui, um typecast é executado de um Objectpara um Integer. Nesse caso, sabemos que isso sempre funcionará, mas a conversão manual de tipos sempre me faz sentir que é um código frágil que pode ser danificado se uma pequena alteração for feita em outro local. (Eu sinto que cada typecast está ClassCastExceptionesperando para acontecer, mas estou divagando ...)

O Integeragora está desempacotado em um inte tem permissão para realizar a adição na intvariável total.

Espero poder ilustrar que os novos recursos do Java 5 podem ser usados ​​com código não genérico, mas não é tão simples e direto quanto escrever código com genéricos. E, na minha opinião, para tirar o máximo proveito dos novos recursos do Java 5, deve-se olhar para os genéricos, se pelo menos permitirem verificações de tempo de compilação para evitar que as previsões de tipos inválidas gerem exceções em tempo de execução.

Se você pesquisar o banco de dados de bugs do Java pouco antes do lançamento do 1.5, encontrará sete vezes mais bugs com do NullPointerExceptionque ClassCastException. Portanto, não parece um ótimo recurso encontrar bugs, ou pelo menos bugs que persistem após um pequeno teste de fumaça.

Para mim, a grande vantagem dos genéricos é que eles documentam em código informações de tipo importantes. Se eu não quisesse que as informações de tipo fossem documentadas em código, usaria uma linguagem digitada dinamicamente ou, pelo menos, uma linguagem com inferência de tipo mais implícita.

Manter as coleções de um objeto para si mesmo não é um estilo ruim (mas o estilo comum é ignorar efetivamente o encapsulamento). Em vez disso, depende do que você está fazendo. Passar coleções para "algoritmos" é um pouco mais fácil de verificar (durante ou antes do tempo de compilação) com os genéricos.

Os genéricos em Java facilitam o polimorfismo paramétrico . Por meio de parâmetros de tipo, você pode passar argumentos para tipos. Assim como um método como String foo(String s)modela algum comportamento, não apenas para uma string específica, mas para qualquer string s, um tipo como List<T>modela algum comportamento, não apenas para um tipo específico, mas para qualquer tipo . List<T>diz que para qualquer tipo T, há um tipo de Listcujos elementos são Ts . Portanto, Listé realmente um construtor de tipo . Ele pega um tipo como argumento e constrói outro tipo como resultado.

Aqui estão alguns exemplos de tipos genéricos que uso todos os dias. Primeiro, uma interface genérica muito útil:

public interface F<A, B> {
  public B f(A a);
}

Essa interface diz que, para alguns tipos, Ae B, há uma função (chamada f) que recebe um Ae retorna um B. Quando você implementa esta interface, Ae Bpode ser qualquer tipo que você quiser, desde que você forneça uma função fque leva a primeira e retorna a última. Aqui está um exemplo de implementação da interface:

F<Integer, String> intToString = new F<Integer, String>() {
  public String f(int i) {
    return String.valueOf(i);
  }
}

Antes dos genéricos, o polimorfismo era obtido pela subclasse usando a extendspalavra - chave. Com os genéricos, podemos realmente eliminar a subclasse e usar o polimorfismo paramétrico. Por exemplo, considere uma classe parametrizada (genérica) usada para calcular códigos hash para qualquer tipo. Em vez de substituir Object.hashCode (), usaríamos uma classe genérica como esta:

public final class Hash<A> {
  private final F<A, Integer> hashFunction;

  public Hash(final F<A, Integer> f) {
    this.hashFunction = f;
  }

  public int hash(A a) {
    return hashFunction.f(a);
  }
}

Isso é muito mais flexível do que usar herança, porque podemos ficar com o tema de usar composição e polimorfismo paramétrico sem bloquear hierarquias frágeis.

Os genéricos do Java não são perfeitos. Você pode abstrair sobre os tipos, mas não pode abstrair sobre os construtores de tipo, por exemplo. Ou seja, você pode dizer "para qualquer tipo T", mas não pode dizer "para qualquer tipo T que receba um parâmetro de tipo A".

Escrevi um artigo sobre esses limites dos genéricos Java, aqui.

Uma grande vitória dos genéricos é que eles permitem que você evite a criação de subclasses. A criação de subclasses tende a resultar em hierarquias de classes frágeis que são difíceis de estender e classes que são difíceis de entender individualmente sem olhar para toda a hierarquia.

Enquanto o teor antes de genéricos você pode ter aulas de como Widgetprorrogado por FooWidget, BarWidgete BazWidget, com os genéricos você pode ter uma única classe genérica Widget<A>que leva um Foo, Barou Bazem seu construtor para lhe dar Widget<Foo>, Widget<Bar>e Widget<Baz>.

Os genéricos evitam o impacto no desempenho do boxing e unboxing. Basicamente, olhe para ArrayList vs List <T>. Ambos fazem as mesmas coisas básicas, mas List <T> será muito mais rápido porque você não precisa encaixotar de / para o objeto.

O melhor benefício para os Genéricos é a reutilização de código. Vamos dizer que você tem muitos objetos de negócios e vai escrever um código MUITO semelhante para cada entidade para executar as mesmas ações. (IE Linq para operações SQL).

Com os genéricos, você pode criar uma classe que será capaz de operar com qualquer um dos tipos que herdam de uma determinada classe base ou implementar uma determinada interface da seguinte forma:

public interface IEntity
{

}

public class Employee : IEntity
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public int EmployeeID { get; set; }
}

public class Company : IEntity
{
    public string Name { get; set; }
    public string TaxID { get; set }
}

public class DataService<ENTITY, DATACONTEXT>
    where ENTITY : class, IEntity, new()
    where DATACONTEXT : DataContext, new()
{

    public void Create(List<ENTITY> entities)
    {
        using (DATACONTEXT db = new DATACONTEXT())
        {
            Table<ENTITY> table = db.GetTable<ENTITY>();

            foreach (ENTITY entity in entities)
                table.InsertOnSubmit (entity);

            db.SubmitChanges();
        }
    }
}

public class MyTest
{
    public void DoSomething()
    {
        var dataService = new DataService<Employee, MyDataContext>();
        dataService.Create(new Employee { FirstName = "Bob", LastName = "Smith", EmployeeID = 5 });
        var otherDataService = new DataService<Company, MyDataContext>();
            otherDataService.Create(new Company { Name = "ACME", TaxID = "123-111-2233" });

    }
}

Observe a reutilização do mesmo serviço, dados os diferentes tipos no método DoSomething acima. Verdadeiramente elegante!

Existem muitos outros excelentes motivos para usar genéricos em seu trabalho, este é o meu favorito.

Eu simplesmente gosto deles porque fornecem uma maneira rápida de definir um tipo personalizado (já que eu os uso de qualquer maneira).

Então, por exemplo, em vez de definir uma estrutura que consiste em uma string e um inteiro, e então ter que implementar um conjunto completo de objetos e métodos sobre como acessar um array dessas estruturas e assim por diante, você pode apenas fazer um Dicionário

Dictionary<int, string> dictionary = new Dictionary<int, string>();

E o compilador / IDE faz o resto do trabalho pesado. Um Dicionário em particular permite que você use o primeiro tipo como uma chave (sem valores repetidos).

• Coleções digitadas - mesmo se você não quiser usá-las, provavelmente terá que lidar com elas de outras bibliotecas, de outras fontes.

• Digitação genérica na criação de classe:

  public class Foo <T> {public T get () ...

• Evitar o elenco - sempre não gostei de coisas como

  new Comparator {public int compareTo (Object o) {if (o instanceof classIcareAbout) ...

Onde você está essencialmente verificando uma condição que deveria existir apenas porque a interface é expressa em termos de objetos.

Minha reação inicial aos genéricos foi semelhante à sua - "muito confuso, muito complicado". Minha experiência é que depois de usá-los um pouco, você se acostuma com eles, e o código sem eles parece menos claramente especificado e apenas menos confortável. Além disso, o resto do mundo java os usa, então você terá que entrar no programa eventualmente, certo?

Os genéricos também oferecem a capacidade de criar objetos / métodos mais reutilizáveis ​​e, ao mesmo tempo, fornecer suporte específico para o tipo. Você também ganha muito desempenho em alguns casos. Não sei as especificações completas do Java Generics, mas no .NET posso especificar restrições no parâmetro Type, como Implementa uma Interface, Construtor e Derivação.

1. Permitindo que os programadores implementem algoritmos genéricos - Usando genéricos, os programadores podem implementar algoritmos genéricos que funcionam em coleções de diferentes tipos, podem ser personalizados e são seguros para tipos e mais fáceis de ler.

2. Verificações de tipo mais fortes em tempo de compilação - Um compilador Java aplica a verificação de tipo forte ao código genérico e emite erros se o código violar a segurança de tipo. Corrigir erros de tempo de compilação é mais fácil do que corrigir erros de tempo de execução, que podem ser difíceis de encontrar.

3. Eliminação de moldes.