Questão de simulado para SCJP

9 respostas
joaoorso

Bem … Estava eu tranqüilo e feliz fazendo um simulado para a prova de SCJP,
e não estava indo tão mal…
Quando de repente :

// Qual linha compila ?

class Carro <T extends Number>{}
class Carro <T extends E>{}
class Carro <T>{}
class Carro <String>{}
class Carro <T implements Comparable>{} // pq ?
class Carro <? extends Number>{}        // pq ?
class Carro <T extends Runnable>{}
class Carro2 <Test,Element>{}

Tudo bem …
Generics eu até conheço… Mas na declaração da classe ???
Que diabos é isso ? :?:

Obrigado a todos que ajudarem !! :thumbup:

9 Respostas

vanderlanio

http://java.sun.com/j2se/1.5/pdf/generics-tutorial.pdf

Valdemar_Jr

São as classes genéricas assim como você faz List lista = new ArrayList(); a declação da classe ArrayList por exemplo é assim

public class ArrayList<E> extends AbstractList<E>.
o códigoclass Carro <T implements Comparable>{}

quer dizer que o tipo genérico dessa classe TEM que implementar Comparable. E o

é chamado de “Super Genérico” hehehehe, que quer dizer que o tipo genérico é desconhecido.

Espero ter ajudado

joaoorso
Acho que ainda não entendi... Então se eu faço isso:
public class ClasseGenerica <String> {
    
}
O compilador não deveria me proibir de fazer isso :
ClasseGenerica<Number> c = new ClasseGenerica<Number>();
:?: :?: E no caso :
class Carro <? extends Number>{}
Significa que o tipo genérico é desconhecido? Como assim . Penssi que seria qualquer coisa que fizer extends em Number . :?: :?: Também ainda não entendi o significado das letras ...
class Carro <T implements Comparable>{}
no caso T
public class ArrayList<E> extends AbstractList<E>
No caso E :?: :?: Desculpe minha ignorância. Obrigado por ajudar ! :thumbup:
Giulliano

Vamos lá…

T = Type
E= Element

Diferença na prática, nenhuma. Na teoria são apenas nomenclaturas padões java. Pode ser X, Y, Z, o que vc quiser…(se não me engano)

se vc diz que :

public class Carro&lt;? extends Number&gt;();

então só poderá instanciar essa classe passando como genérico algo que extenda ou implemente number…ou ainda não passar ninguém poq genéricos não são obrigatórios…servem apenas para tempo de compilação.

Se vc põe ? significa q vc não sabe o que virá…por isso o sinal.

Se vc põe String…então acredito q o compilador não deixe usar um Number…

mesmo pq a idéia às vezes é receber uma String para usar métodos de String e Number não os possui.

joaoorso

Pior que o compilador deixa… Fiz esse código :

public class ClasseGenerica &lt;String&gt; {
    
}

ClasseGenerica&lt;Number&gt; c = new ClasseGenerica&lt;Number&gt;();

E rodou normalmente.

Então para que colocar <? extends Number>
Se eu não sei o que virá não deveria ser apenas <?>

Muito obrigado pela ajuda Giulliano… Já vejo uma luz no fim do túnel.

Também estou com dificuldades em entender :
http://www.guj.com.br/posts/list/93491.java#500713

Obrigado novamente :thumbup:

victorwss

Isso é o que eu acho:

// Qual linha compila ?

// Compila.
class Carro <T extends Number>{}

// E não está definido em lugar algum. Não compila.
class Carro <T extends E>{}

// Compila, T é alguma classe que herde de Object.
class Carro <T>{}

// Pegadinha FDP. Compila sim! String é o nome dado ao parâmetro de tipo, e não a classe java.lang.String!
class Carro <String>{}

// Não compila. "implements" não é válido em generics.
class Carro <T implements Comparable>{}

// Não compila. Você tem que dar um nome ao seu generic aqui.
class Carro <? extends Number>{}

// Compila. generics sempre usa "extends", mesmo para interfaces.
class Carro <T extends Runnable>{}

// Compila. Dois generics.
class Carro2 <Test,Element>{}
maior_abandonado

então…tem uma apostila de generics mto boa do jedi…vc pode se escrever no curso, é o segundo curso deles se nao me engano…

se quiser eu te mando ela…

me manda essa imagem do dragão ai, q eu te retorno com ela…rs

joaoorso

Muito bem.
Assunto praticamente entendido.
Obrigado a todos que ajudaram. :thumbup:

/* *************  Classes Genéricas ********************** */

// Compila.
class Carro1 <E extends Number>{}  

// Compila.
class Carro2 <T>{} 

// Compila.
class Carro3 <G>{} 

// Compila.
class Carro4 <String>{}  

// Compila.
class Carro5 <Xuxuzinho>{}

// Compila.
class Carro6 <T extends Comparable>{} 

// Compila.
class Carro7 <Test, Element>{} 

// Compila.
class Carro8 <Test, Element, Xunda, BregNights>{} 

// Compila. generics sempre usa "extends", mesmo para interfaces.  
class Carro9 <T extends Runnable>{}  

// Não compila. "implements" não é válido em generics.  
class Carro10 <T implements Comparable>{} 

// Não compila. Você tem que dar um nome ao seu generic aqui.  
class Carro11 <? extends Number>{} 

// G não está definido em lugar algum. Não compila. 
class Carro2 <T extends G>{}

A apostila enviada por maior_abandonado; também foi de exelente ajuda.
Só continuo achando que o compilador não deveria deixar isso acontecer :

public class ClasseGenerica <String> {
    
}

ClasseGenerica<Number> c = new ClasseGenerica<Number>();

Ainda me resta uma dúvida, neste tópico:
http://www.guj.com.br/posts/list/93491.java#501751

Obrigado. :thumbup:

joaoorso
Eu mesmo :
Só continuo achando que o compilador não deveria deixar isso acontecer :
Olha só ...
public class ClasseGenerica &lt; String&gt; {
    
    public void first(String ... args){
        ClasseGenerica&lt;Number&gt; c = new ClasseGenerica&lt;Number&gt;();
    }    
}
Compila normalmente, < String> é o nome do generic.

Estava confundindo. O compilador não pode deixar isso acontecer :

public class ClasseGenerica &lt; T extends String&gt; {
    
    public void first(String ... args){
        ClasseGenerica&lt;Number&gt; c = new ClasseGenerica&lt;Number&gt;();// Erro de compilação
        //ClasseGenerica&lt;String&gt; c = new ClasseGenerica&lt;String&gt;();// compila
    }    
}

Agora sim !!! 8)
Tudo entendido. Só restou a pequena dúvida no outro tópico, cidado acima.

Obrigado a todos ! :thumbup:

Criado 6 de junho de 2008
Ultima resposta 13 de jun. de 2008
Respostas 9
Participantes 6