Uma introdução:
Antes do Javase 1.5, sem genéricos, a "arbitrário" dos parâmetros foi alcançada referenciando o objeto de tipo. 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.
2. Parâmetros genéricos:
classe Gen <t> {private t ob; // define variável genérica variável public gen (t ob) {this.ob = ob;} public t getOb () {return ob;} public void setob (t ob) {this.Ob = ob;} public void showType () {System.It.Intln ("o tipo de tipo real é:" classe GenicParameter {public static void main (string [] args) {// define uma versão inteira da classe genérica Gen <Teger> intob = new Gen <Teger> (100); Intob.Showtype (); int i = Intob.GetoOb (); System.out.println ("Value =" " i); system.out.println ("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- saída:
O tipo real de t é: java.lang.integer
valor = 100
--------------------------------------------------------------------------------------------------------------------------------------------------
O tipo real de t é: java.lang.string
Valor = Olá Dylan!
3. Genéricos:
classe GenicSfoo <T> {private t x; public GenericsFoo (t x) {this.x = x;} public t getx () {return x;} public void Setx (t x) {this.x = x;}} classe pública genricclass {public static void main (string genen) <) {geneticsfoo Genéricos! "); Genericsfoo <ouble> doufoo = new GenericsFoo <double> (new Double (" 33 ")); genricsfoo <ject> objfoo = new Genericsfoo <juste> (novo Object ()); system.out.println ("strfoo.getx ="+strfoo.getx ()); system.out.println ("doufoo.getx ="+doufoo.getx ()); system.out.println ("objfoo.getx ="+objfoo.getx (); saída:
strfoo.getx = olá genéricos!
doufoo.getx = 33.0
objfoo.getx=java.lang.object@1d0fafc
Genéricos de quatro limites:
importar java.util.ArrayList; importar java.util.Collection; classe collectionGenfoo <t estende a coleção> {private t x; public collectionGenfoo (t x) {this.x = x;} public t getx () {return x;} public setx (t x) {this.x = x;} {ColeçãoGenFoo <RrayList> listFoo = null; listFoo = new CollectionGenFoo <ArrayList> (new ArrayList ()); collectionGenFoo <? estende a coleção> listFoo1 = null; listFoo1 = new CollectionGenFoo <ArrayList> (new ArrayList ()); System.out.println ("Instanciação bem -sucedida!");}}} saída:
A instanciação foi bem -sucedida!
Cinco métodos genéricos:
classe pública GenicFunction {public <t> void f (t x) {System.out.println (x.getclass (). getName ());} public static void main (string [] args) {genricfunction ea = New GenericFunction (); ea.f ("); ea.f (10); saída:
java.lang.string
java.lang.integer
java.lang.Character
Função genérica
--------------------------------------------------------------------------------------------------------------------------------------------------
Dylan apresenta.
Resumir
O exposto acima é todo o conteúdo deste artigo sobre a explicação detalhada dos exemplos genéricos em Java, espero que seja útil para todos. Se houver alguma falha, deixe uma mensagem para apontá -la. Obrigado amigos pelo seu apoio para este site!