Genericos

Para manter a compatibilidade de códigos antigos pré-genéricos com códigos novos (a partir de java 5). Repare que o código compila com avisos exatamente por esse motivo, para chamar a atenção do programador de que problemas poderão ocorrer em tempo de execução.

somente a Opção 1 compila com o nosso amigo javadev falow !!!as outras são tipos imcopátiveis de Genericos…

Raff só quem é incompativel é a 3 opção já que ela é do tipo Animal e o método só aceita Dog. Mas entendi pq a primeira opção compila. Mas no meu pc o código não ta gerando avisos será pq a JVM é a 1.6?

A opção 2 não compila. Ela faz um set de Dog e o método exige um Set de Dog2.

só se você escreveu erro o código cara porque olha lá no metodo go(Dog2 o){} então poderia ser assim somente…

public static void go(Set<Dog> a ){
}//dai sim funcionario a opção 2...
//ou

public static void go(Set<? extends Animal> a){
//só que esse metodo não pode add nada...
}

//ou

public static void go(Set<?> a){
//juntamente por aceitar qualquer coisa não se pode add nada nesse Set...

}//um Set de qualquer coisa Animal, Horse....enfim tudo...


public static void go(Set<? super Dog> a){
//aceito tudos que estiverem acima de Dog na Hierarquia....
//e esse metodo pode add..

}

A opção 2 não compila. Ela faz um set de Dog e o método exige um Set de Dog2.

Desculpa thingol não reparei esse problema. Mas é Dog2 na opção 2 foi erro de digitação mesmo.

Vou corrigir o problema.
:lol:

Quero agradecer a todos pela força.

Aproveitando o tópico aberto do nosso amigo anderson.bonavides
tenho o seguinte problema sobre genéricos:
No livro da Kathy Sierra 2 edição diz que este metodo a seguir:

static <T extends Animal> void add(T t){
       ArrayList<T> y=new ArrayList<T>();
          y.add(t);
          System.out.print(y.get(0).n);
 
      }
//É EQUIVALENTE A ESTE ABAIXO=

 static void add2(Dog t){
       ArrayList<Dog> y=new ArrayList<Dog>();
          y.add(t);
         System.out.println(y.get(0).n);
      }

Mas fiquei confuso ao fazer o seguinte:

import java.util.*;

class Animal {
String n;
}
class Dog extends Animal {
 Dog(String i){
      n=i;  
    }
  // public String toString(){
  //     return n;
 //  }
}
public class Vai{
       static <T> void add(T t){
       ArrayList<T> y=new ArrayList<T>();
          y.add(t);
          System.out.print(y.get(0).n);///erro de compilacao ,parece que n nao esista,para ajeitar a unica saída seria <T extends Animal>
 
      }
       static void add2(Dog t){
       ArrayList<Dog> y=new ArrayList<Dog>();
          y.add(t);
         System.out.println(y.get(0).n);
      }

      public static void main(String...a) {
      add(new Dog("cachorro"));
     
    }
    
}

Não entendi o pq desse erro de compilação.No entanto se eu sobrescrever o metodos public String toString() {}imprime cachorro ,ou seja reconhece a variável de instância dentro de Dog.Bom galera, se alguem tiver uma sujestão seria uma boa, valeu!!

Já verificou que sua classe Animal não tem um construtor com argumento? Eu não testei aki mas acho que vai ficar blz.
Espero ter ajudado. t+

anderson.bonavides:

Já verificou que sua classe Animal não tem um construtor com argumento? Eu não testei aki mas acho que vai ficar blz.
Espero ter ajudado. t+

fabioEM,

Para funcionar você precisa fazer uma conversão explicita.
Por que o compilador não sabe que “T” é um Animal. Então ele não vai achar o metodo n.

Eu poderia fazer isso e estaria correto:

Dog dog = new Dog("cachorro");
Vai.add(dog);

Mas eu também poderia fazer isso:

Alien alien = new Alien();
Vai.add(alien);

em tempo de excução isto geraria um erro porque
alien não é um animal, portanto não tem o metodo n.

Por isso o compilador gera um erro.

Desculpas acabo de apagar a observacao errada que tinhya feito a vc marcosbrandao
e me corrijo, tens razao, realmente a única saida é fazer uma conversao explicita!!
obrigado a pressa é inimiga da perfeicao mesmo!!

Ola galera ,aproveitando esse tópico e fazendo um “reuso” como boa engenharia de computação , pq isso esta errado?observem:

class OpaOQueEisssoo{
  static List<? extends Number> process(List t){
      return null;
  }
    
  public static void main(String...a) {
           ArrayList<Number> lista=new ArrayList<Number>(); 
           List<Integer> listaInteger = process2(lista);//erro de compilacao
  }
}

ou seja, tenho um tipo de retorno bem abrangente,mas ao mesmo tempo tempo o compilador nao açeita ,será que isso tem aver com apagamento de tipos que a Kathy fala no livro?
List=

fabioEM:

Ola galera ,aproveitando esse tópico e fazendo um "reuso" como boa engenharia de computação , pq isso esta errado?observem:

class OpaOQueEisssoo{
  static List<? extends Number> process(List t){
      return null;
  }
    
  public static void main(String...a) {
           ArrayList<Number> lista=new ArrayList<Number>(); 
           List<Integer> listaInteger = process2(lista);//erro de compilacao
  }
}

ou seja, tenho um tipo de retorno bem abrangente,mas ao mesmo tempo tempo o compilador nao açeita ,será que isso tem aver com apagamento de tipos que a Kathy fala no livro? List=

static List<? extends Number> process(List t){

return null;
}

public static void main(String... rafa){
List<Integer> b = new ArrayList<Integer>();
List<? extends Number> a = process(b);// assim não daria erro de compilação teste ai !!!!

}

[]'s

Raff:

fabioEM:

Ola galera ,aproveitando esse tópico e fazendo um "reuso" como boa engenharia de computação , pq isso esta errado?observem:

class OpaOQueEisssoo{
  static List<? extends Number> process(List t){
      return null;
  }
    
  public static void main(String...a) {
           ArrayList<Number> lista=new ArrayList<Number>(); 
           List<Integer> listaInteger = process2(lista);//erro de compilacao
  }
}

ou seja, tenho um tipo de retorno bem abrangente,mas ao mesmo tempo tempo o compilador nao açeita ,será que isso tem aver com apagamento de tipos que a Kathy fala no livro? List=

Olá Fábio bom dia. Seguinte cara da uma arrumanda ai no nome do seu metodo uma vc chama process no main() vc chama process2.. mas enfim nesse seu tipo de retorno a única coisa que compilaria seria se você tivesse algo do tipo...

static List<? extends Number> process(List t){

return null;
}

public static void main(String... rafa){
List<Integer> b = new ArrayList<Integer>();
List<? extends Number> a = process(b);// assim não daria erro de compilação teste ai !!!!

}

[]'s

Ok entao quer dizer que o processo de eu dar um limite para algum tipo de retorno para um conjunto X deve sempre ser novamente refeito,ok beleza, mas entao para se dar o trabalho ,se depois deve sempre acrescentar o mesmo tipo de código?? :roll:mas valeu pelo esclarecimento!!

static List<? extends Number> process(List t){   
      return null;   
  }
       ArrayList<Number> lista=new ArrayList<Number>();  
     List<? extends Number> listaInteger1 = process(lista);
     List<? extends Number> listaInteger2 = process(lista);  
    +.  .   .+
   //vai saber...