import java.util.*;
class Animal{}
class Dog2 extends Animal{}
public class Gen3 {
public static void go(Set<Dog2> d){}
public static void main(String[] args){
//Inserir opção aqui.
go(t);
}
}
Opções:
opc1: TreeSet t = new TreeSet();
opc2: TreeSet t = new TreeSet();
opc3: TreeSet t = new TreeSet();
Galera alguêm poderia me explicar pq a opção 1 compila?
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.
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?
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..
}
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:
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!!
[quote=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+[/quote]
Ja verifiquei cara mas nao é isso nao é algo bem mais sinistro…nao consigo entender cara !!mas valeu ai!!
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=
[quote=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=[/quote]
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…[code]
static List<? extends Number> process(List t){
return null;
}
public static void main(String… rafa){
List b = new ArrayList();
List<? extends Number> a = process(b);// assim não daria erro de compilação teste ai !!!
[quote=Raff][quote=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=[/quote]
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…[code]
static List<? extends Number> process(List t){
return null;
}
public static void main(String… rafa){
List b = new ArrayList();
List<? extends Number> a = process(b);// assim não daria erro de compilação teste ai !!!
}
[/code]
[]'s[/quote]
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!!