A maneira mais fácil de entender os genéricos do Java é considerá -lo uma sintaxe conveniente que pode economizar algumas operações no Java Type Casting:
Lista <pple> caixa = ...; Maçã maçã = box.get (0);
O próprio código acima expressou claramente: a caixa é uma lista com objetos da Apple. O método GET retorna uma instância do objeto Apple e esse processo não requer conversão de tipo. Não há genéricos, o código acima precisa ser escrito assim:
Lista Box = ...; Apple Apple = (Apple) Box.get (0);
É óbvio que o principal benefício dos genéricos é permitir que o compilador mantenha as informações de tipo dos parâmetros, execute verificações de tipo e execute operações de conversão de tipo: o compilador garante que essas conversões de tipo estejam absolutamente corretas. Comparado com a base de programadores para lembrar os tipos de objetos e executar conversões de tipo - isso causará falhas quando o programa for executado, o que é difícil de depurar e resolver. O compilador pode ajudar os programadores forçar um grande número de verificações de tipo no horário de compilação e a encontrar erros.
A composição de genéricos
A composição dos genéricos leva ao conceito de variáveis de tipo. De acordo com a especificação do idioma Java, as variáveis de tipo são um tipo de glifo irrestrito, que surge das seguintes situações:
Declaração de classe genérica Declaração genérica Declaração Declaração genérica Declaração Declaração do construtor genérico
Classes e interfaces genéricas
Se houver uma ou mais variáveis de tipo em uma classe ou interface, é um genérico. As variáveis de tipo são definidas por suportes de ângulo e colocadas após a classe ou o nome da interface:
Lista de interface pública <T> estende a coleção <T> {...}Simplificando, o papel das variáveis de tipo é como um parâmetro, que fornece informações ao compilador para verificação do tipo.
Muitas classes na biblioteca de classes Java, como toda a estrutura da coleção, foram modificadas em forma genérica. Por exemplo, a interface da lista que usamos no primeiro código acima é uma classe genérica. Nesse código, a caixa é um objeto de lista <pple>, que é uma instância de uma implementação de classe de uma interface de lista com uma variável do tipo Apple. O compilador usa esse parâmetro de variável de tipo para converter automaticamente o método GET quando é chamado e retorna um objeto Apple.
De fato, essa tag genérica recém -emergente, ou o método GET nesta interface da lista, é o seguinte:
T Get (Int Index);
O método GET realmente retorna um objeto do tipo T, que é uma variável de tipo na declaração da lista <t>.
Métodos e construtores genéricos
Muito semelhante, se uma ou mais variáveis de tipo forem declaradas no método e no construtor, elas também podem ser genéricas.
public static <t> t getfirst (lista <t> list)
Este método aceitará uma lista <T> e retornará um objeto do tipo T. Você pode usar as classes genéricas fornecidas na biblioteca de classes Java ou usar suas próprias classes genéricas. Dados de escrita à segurança do tipo ... o código a seguir é um exemplo. Criamos uma instância da lista <String> e, em seguida, carregamos alguns dados:
List <tring> str = new ArrayList <String> (); str.add ("Olá"); str.add ("mundo");Se tentarmos carregar outro objeto na lista <String>, o compilador solicitará um erro:
str.add (1);
Dados de leitura seguros de tipo ...
Quando estamos usando um objeto de uma lista <String>, ele sempre garante que obtemos um objeto String:
String myString = str.get (0);
Traversal: Muitas classes na biblioteca de classes, como o iterador <T>, têm funções aprimoradas e são genéricas. O método iterator () na interface da lista agora retorna o iterador <T>. O objeto retornado pelo seu método t próximo () não precisa ser convertido em tipo, você obtém diretamente o tipo correto.
for (iterator <string> iter = str.iterator (); iter.hasnext ();) {string s = iter.next (); system.out.print (s);}Com a foreach, a sintaxe "para cada" também se beneficia dos genéricos. O código anterior pode ser escrito assim:
for (string s: str) {system.out.print (s);}Isso é fácil de ler e manter.
Encapsulamento automático (auto -boxing) e descompacagem automática (AutounBoxing). Ao usar os genéricos do Java, os dois recursos do AutoBoxing/AutounBoxing serão usados automaticamente, assim como o seguinte código:
Lista <Teger> ints = new ArrayList <Teger> (); ints.add (0); ints.add (1); int sum = 0; para (int i: ints) {sum += i; }No entanto, uma coisa que você precisa entender é que a embalagem e a descompactação trarão perdas de desempenho e, tudo, o objetivo geral deve ser usado com cautela.
Os genéricos são um novo recurso do Java SE 1.5. A essência dos genéricos é um tipo parametrizado, ou seja, o tipo de dados operado é especificado como um parâmetro. Esse tipo de parâmetro pode ser usado na criação de classes, interfaces e métodos e é chamado de classes genéricas, interfaces genéricas e métodos genéricos, respectivamente.
A vantagem de introduzir genéricos no idioma Java é que eles são seguros e simples.
Antes de Java SE 1.5, sem genéricos, a "arbitrário" dos parâmetros foi alcançada referenciando o objeto Type. A desvantagem da "arbitrária" foi que a conversão explícita do tipo de elenco era necessária e essa conversão exigia que os desenvolvedores prevejam o tipo de parâmetro real. No caso de erros de conversão do tipo de elenco, o compilador pode não solicitar um erro, e uma exceção ocorrerá apenas quando estiver em execução, o que é um risco de segurança.
A vantagem dos genéricos é que eles verificam a segurança do tipo ao compilar, e todos os elencos são automáticos e implícitos, melhorando a taxa de reutilização do código.
Existem algumas regras e restrições no uso de genéricos:
1. Os parâmetros de tipo de tipos genéricos podem ser apenas tipos de classe (incluindo classes personalizadas), não tipos simples.
2. O mesmo tipo genérico pode corresponder a várias versões (porque o tipo de parâmetro é incerto) e as instâncias de classe genérica de versões diferentes são incompatíveis.
3. Pode haver vários parâmetros de tipo para genéricos.
4. Os tipos de parâmetros genéricos podem usar as instruções estendidas, por exemplo. Habitualmente se tornando um "tipo limitado".
5. O tipo de parâmetro de um tipo genérico também pode ser do tipo curinga. Por exemplo, classe classtype = classe.formaName (java.lang.string);
Os genéricos também têm interfaces, métodos, etc., com muito conteúdo, e é preciso algum esforço para entender, dominar e aplicá -los proficientemente. Aqui estão dois exemplos que escrevi quando aprendi sobre genéricos (escritos com base na impressão que vi), que podem realizar a mesma função. Um usa genéricos e o outro não. Através da comparação, você pode aprender rapidamente a aplicação de genéricos. Aprenda isso e basicamente aprenda 70% do conteúdo dos genéricos.
Exemplo 1: genéricos são usados
classe pública gent {private t ob; // define variável de membro genérico public gen (t ob) {this.ob = ob; } public t getob () {return ob; } public void setob (t ob) {this.ob = ob; } public void showtyep () {System.out.println ("O tipo real de t é:" + ob.getclass (). getName ()); }} classe pública gendemo {public static void main (string [] args) {// define uma versão inteira da classe genérica geng gen Intob = new Geninteger (88); Intob.showtyep (); int i = intob.getob (); System.out.println ("value =" + i); System.out.println ("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------Exemplo 2: Nenhum genérico é usado
classe pública gen2 {objeto privado ob; // define um membro geral do tipo público gen2 (objeto ob) {this.ob = ob; } public object getob () {return ob; } public void setob (objeto ob) {this.ob = ob; } public void showtyep () {System.out.println ("O tipo real de t é:" + ob.getclass (). getName ()); }} classe pública gendemo2 {public static void main (string [] args) {// define uma versão inteira da classe gen2 gen2 intob = new Gen2 (new Integer (88)); Intob.showtyep (); int i = (integger) integ.getOb (); System.out.printl (); i);System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ strob.getOb (); System.out.println ("value =" + s);Resultados em execução:
Os resultados da execução da demonstração nos dois exemplos são os mesmos, e a saída do console é a seguinte:
O tipo real de t é:
java.lang.integer
valor = 88
------------------------------------
O tipo real de t é: java.lang.string
valor = olá gen!
Processo terminado com o código de saída 0
Se você entender isso, não será um problema no futuro quando aplicativos genéricos básicos e leitura de código.
O acima é um exemplo de análise dos genéricos do Java. Amigos que aprendem genéricos de java podem se referir a ele.