A maior parte da informação, pelo menos as mais confiáveis e completas, está em inglês.
Posso perquisar alguma documentação em português sobre generics, mas sugiro que você aproveite para treinar o inglês, pois hoje conhecer uma segunda língua não é mais diferencial: tornou-se algo que espera-se seja inerente a todo profissional.
[quote]A) public static Collection<? extends CharSequence>
getLongWords(Collection coll) [/quote]
Invalido pq ? nao é um modificador válido para generics
[quote]B) public static List
getLongWords(Collection coll) [/quote]
o tipo de retorno é invalido é uma List e observe que o metodo retorna Collection. que é pai de List.
[quote]D) public static List
getLongWords(Collection coll) [/quote]
Olha o tipo de retorno do metodo novamente invalido. A letra E é o tipo de retorno do metodo novamente.
Agora as C,G eu nao conseguir acha o pq… mais nao marcaria eles…
Bom acho que isso mais… meio confusa essa questao nao tem coisa desse tipo la nao ta mais leve hehe em relacao a generics… o q tem muito é a mistura do 1.4 com 1.5…
[quote=anderson.bonavides]Galéra alguêm poderia me dar uma explicação detalhada dessa questão? Desculpem mas não entendi praticamente nada.
A resposta corréta é a letra F.
Quais declarações de poderiam ser inseridas no comentário INSIRA A DECLARAÇÃO AQUI de forma que o progrma compile e rode?
import java.util.*;
public class LongWordFinder {
public static void main(String[] args) {
String[] array = {"123", "12345678", "1", "12", "1234567890"};
List <String> list = Arrays.asList(array);
Collection<String> resultList = getLongWords(list);
}
//INSIRA A DECLARAÇÃO DE MÉTODO AQUI.
{
Collection<E> longWords = new ArrayList<E>();
for(E word: coll)
if(word.length() > 6) longWords.add(word);
return longWords;
}
}[/code]
A) public static <E extends CharSequence> Collection<? extends CharSequence>
getLongWords(Collection<E> coll)
B) public static <E extends CharSequence> List<E>
getLongWords(Collection<E> coll)
C) public static Collection<E extends CharSequence>
getLongWords(Collection<E> coll)
D) public static List<CharSequence>
getLongWords(Collection<CharSequence> coll)
E) public static List<? extends CharSequence>
getLongWords(Collection<? extends CharSequence> coll)
[b]F) static public <E extends CharSequence> Collection<E>
getLongWords(Collection<E> coll)[/b]
G) static public <E super CharSequence> Collection<E>
getLongWords(Collection<E> coll)[/quote]
vamos lá
a) está tudo ok! Com exceção do tipo de retorno que é muito "extenso..." note que voce espera [code]Collection<String> e não Collection<? extends CharSequence >[/code] se fosse [code]Collection<? extends CharSequence> resultList = getLongWords(list)[/code] estario tudo OK !!!!
b) está não vai compilar porque dentro do metodo getLongWords() faz [code]Collection<E> longWord = new ArrayList<E>(); [/code] e retorna isso sendo que o teste é - um falha (Collection é uma List ?(falha...))
c) é uma sintaxe incorreta o metodo aqui não está sendo uma método genérico correto!! ele é assim
[code]public static Collection<E extends CharSequence> getLongWords(Collection<E> c){...}[/code]
note que para um metodo ser generico precisa declarar que o mesmo é generico, e esse metodo não faz isso !
d) esse de cara já da para matar que está errado pois isso é a parte mais simples de generico.. vamos lá um exemplo..
[code]List<Integer> inter;
List<String> stringg;
inter = stringg; // isso é correto ?// esse é um dos motivos desse metodo não poder ser o correto.
e) a sintaxe do metodo está certinha mas o que está errado é o tipo de retorno do metodo.
f) é o certo.
g) está errado a sintaxe não se pode usar public static <E super CharSequence> ....... somento a palavra extends…
import java.util.*;
public class LongWordFinder {
public static void main(String[] args) {
String[] array = {"123", "12345678", "1", "12", "1234567890"};
List <String> list = Arrays.asList(array);
Collection<String> resultList = getLongWords(list);
}
// A) não vale porque getLongWords retorna uma Collection<? extends CharSequence> que
// nem sempre é um Collection<String>. (Embora uma Collection<String> seja uma Collection<? extends CharSequence>,
// o contrário não é verdade.
// B) não compila porque o tipo de retorno é List<E>, mas estamos tentando retornar uma Collection<E>.
// (Embora uma List<E> seja uma Collection<E>, o contrário não é verdade.
// C) não compila porque, para um método estático, é necessário especificar o tipo <E> antes
// da declaração do tipo de retorno. Neste caso, deveria ser: <E extends CharSequence>. Ou seja:
// public static <E extends CharSequence> Collection<E> getLongWords(Collection<E> coll)
// D) não compila porque E não está especificada em lugar nenhum
// E) não compila porque E não está especificada em lugar nenhum
// F) compila OK
// G) Podemos usar <E extends CharSequence>, mas não <E super CharSequence>; no máximo,
// <? super CharSequence>.
static public <E extends CharSequence> Collection<E> getLongWords(Collection<E> coll)
{
Collection<E> longWords = new ArrayList<E>();
for(E word: coll)
if(word.length() > 6) longWords.add(word);
return longWords;
}
}
Ralf, thingol, LpJava e rdomartins. Muito obrigado vocês pela força. Essa galéra do Guj é muito gente fina. Apesar de já ter feito a prova acho q não cai nenhuma questão grande assim ou cai?
rs vlw a todos!
