1. O conceito básico de genéricos
Como C#, o Java tem o conceito de genéricos e a parametrização dos tipos. Os genéricos em Java aparecem após o JDK5.0, mas os genéricos em Java são essencialmente diferentes dos genéricos em C#. Primeiro de tudo, da perspectiva dos tipos de coleta, Arraylist <Teger> e ArrayList <String> em Java são do mesmo tipo. A apagamento do tipo será realizada durante a compilação e os tipos de Java são pseudogenéricos. A pseudogenérica será introduzida posteriormente. Em segundo lugar, ao adicionar tipos básicos de dados a uma coleção, como o INT, INT, primeiro serão convertidos em um objeto inteiro, que é o que geralmente chamamos de operação de boxe. Ao retirar os elementos, o objeto interger precisa ser convertido em um tipo de valor int, ou seja, operação de unboxing. Em C#, list <int> e list <string> são tipos diferentes. Os parâmetros genéricos serão um espaço reservado após a compilação e não serão apagados. Eles recebem tipos reais em tempo de execução. Eles são gerados durante o tempo de execução do sistema e têm suas próprias tabelas de método virtual e dados de tipo. Essa implementação é chamada de inflação do tipo (para inflação do tipo, o compilador instantâneo fez muito trabalho de otimização para resolver esse problema). Este é o chamado verdadeiro genéricos. Ao mesmo tempo, ao adicionar elementos básicos como o INT a uma coleção, não há necessidade de encaixar e não é necessário unboxing ao retirar elementos. Portanto, o desempenho é melhor que os genéricos da coleção Java.
A introdução de genéricos em Java é principalmente para resolver dois problemas: 1. As exceções de substituição do tipo ocorrem durante o tempo de execução do elemento do tipo de coleção e as verificações de tipo são adicionadas durante o tipo de tempo de compilação. 2. Repita a redação do código durante a solução e o algoritmo pode ser reutilizado. A seguir, é apresentado um exemplo para ilustrar a verificação de tipo do compilador.
Primeiro, vejamos um exemplo em que os genéricos não são usados:
Arraylist al = new ArrayList (); al.add ("abc"); al.add ("124"); al.add ("32L");Podemos adicionar qualquer tipo de dados à coleção AL. Quando precisamos converter o tipo ao buscar os dados, como:
String s = (string) al.get (0); string s1 = (string) al.get (1); // No período de execução, um erro será relatado e o erro de conversão do tipo será longo l = (longo) al.get (2);
A partir disso, podemos ver que, quando não houver genéricos, a verificação do tipo é reduzida durante a compilação. Ao retirar os elementos, os programadores precisam conhecer os tipos de cada elemento, caso contrário, uma exceção da conversão de tipo pode ocorrer em tempo de execução.
Então, vamos dar uma olhada nos benefícios que isso nos traz por meio de coleções genéricas.
ArrayList <String> al1 = new ArrayList <String> (); al1.add ("abc"); al1.add (1); // ocorreu um erro durante a compilação,Quando instanciamos o Al1 com o tipo de parâmetro da string, não podemos adicionar um elemento int, caso contrário, o compilador relatará um erro. Geralmente, haverá uma marca de erro no editor IDE, como o Eclipse. Ao mesmo tempo, não há necessidade de digitar conversão ao extrair o elemento.
String value = al1.get (0); // nenhuma conversão de tipo é necessária
Este é o benefício dos genéricos.
Em seguida, a multiplexação dos algoritmos é refletida principalmente na multiplexação de métodos, como o método Add do Arraylist, que pode ser usado em qualquer tipo ou tipo limitado.
2. Uso de genéricos
Os genéricos do Java são usados principalmente em classes, métodos e interfaces. Primeiro, vamos dar uma breve olhada no uso da aula:
classe fábrica <T> {Valor T privado; public t getValue () {retornar valor; } public void setValue (t v) {this.value = v; }}Adicionar método de teste:
Factory <string> f = new Factory <String> (); F.SetValue ("Fábrica em uso"); System.out.println (f.getValue ());Uso de interfaces genéricas:
interface myInterface <t, u> {void show (t t, u u); } classe ShowTest implementa MyInterface <String, Integer> {@Override public void show (String t, Integer u) {System.out.println (t); System.out.println (u); }}Quando um parâmetro de tipo genérico atua em uma classe, ele restringe principalmente as restrições de tipo entre vários campos e assinaturas de método. Ao agir em um método, as principais restrições são feitas em vários parâmetros do método. Aqui, os parâmetros de tipo genérico do método não receberão mais exemplos. Vamos apresentar principalmente as restrições dos parâmetros de tipo abaixo.
3. Tipo de restrições de parâmetros
Vejamos um pequeno exemplo, conforme mostrado no código a seguir:
public static <t> t get (t t1, t t2) {if (t1.compareto (t2)> = 0); // erro de compilação, o método compareto (t) é indefinido para o tipo T. retornar t1; }Você pode ver a mensagem de erro do compilador. O método compareto não é definido para o tipo T. Se os tipos precisarem ser comparados no Java, a interface comparável precisará ser implementada, para que o método seja substituído. Então fazemos as seguintes modificações:
public static <t estende comparável> t get (t t1, t t2) {// Adicione limitação de tipo if (t1.compareto (t2)> = 0); retornar t1; }Ao qualificar o T se estende comparável, mostra que T é o tipo de interface que implementa comparável e, portanto, também implementa o método compareto, portanto, não haverá erros de tempo de compilação.
Quando usamos e para segmentar múltiplas limitações de tipos, podemos usar e para segmentar as palavras -chave limitadas, e apenas as estendências podem ser usadas. Ao mesmo tempo, quando existem interfaces e tipos, a classe só pode ser colocada primeiro e só pode ter uma, como mostrado abaixo:
<T estende o objeto e comparável e serializável>
O artigo acima discute brevemente o papel e os conceitos básicos dos genéricos da Java é todo o conteúdo que compartilho com você. Espero que você possa lhe dar uma referência e espero que você possa apoiar mais o wulin.com.