Dúvidas

o Deprecated ira mostrar um waring sempre que este método for chamado

esse genercs vou ficar devendo…

Deprecated significa que é um método “depreciado” (seria essa a tradução?), ou seja, que não é bem visto na hora de se utilizar, normalmente ele indicará outra forma mais atualizada de se fazer.

Obrigado galera alguém sabe referente ao casting ?

Acabei de ver em outro tópico, Deprecated = Desuso.

Quanto ao Casting, quando voce cria a classe CarroEspecífico voce sobrescreveu os métodos herdados da classe Carro.

Interrogação é o coringa do generics, significa qualquer tipo!
No caso essa interrogação está vindo seguida por extends E, que significa que o método recebe como argumento uma Collection de qualquer tipo que extenda ou implemente E.

Por exemplo, se vc declara Collection vc pode apenas utilizar Animal mas não pode passar uma referencia de alguma coisa que extenda Animal.

List<Animal> animals = new ArrayList<Animal>();
List<? extends Animal> animals2 = new ArrayList<? extends Animal>();
Animal animal = new Dog();
Dog dog= new Dog();

//valid
animals.add(animal);
//invalid
animals.add(dog);

//valid
animals2 .add(animal);
animals2 .add(dog);

Espero que tenha ajudado!

@Deprecated = Perigo: Quem ousar utilizar este método será condenado a morte de forma dolorosa, violenta e cruel.

O cast é aquele ((Carro) obj) do seu código, que no caso é completamente desnecessário porque obj já é do tipo Carro.
Enfim o cast serve para você dizer para o compilador tratar aquilo como algo de um tipo diferente do que o tipo que ele vê.

No generics o Collection<? extends E> significa “uma Collection de E ou de alguma subclasse de E”. Assim como Collection<? super E> significa “uma Collection de E, de alguma superclasse de E ou de alguma interface implementada por E”. Collection quer dizer “uma Collection de E (exatamente E, não é nem de uma subclasse de E e nem de uma superclasse de E, mas exatamente de E)”.
Por fim Collection<?> significa “qualquer Collection”.

GustavoLaguna , ainda estou com algumas dúvidas referente à casting.

No meu exemplo anterior até faz sentido pois eu deu um override nos métodos da
minha classe mãe, mais neste exemplo que vou mostra agora eu não do e acontece um problema veja o código abaixo:

package modulo03Lab.exercicio01;


class Carro
{
	public String modelo()
	{
		return "Fiat";
	}
	
	public  String anoFabricacao()
	{
		return "12/12/2008";
	}
	
	
}

class CarroEspecifico extends Carro
{
	public String modelo()
	{
		return "Punto";
	}
	
	public  String anoFabricacao()
	{
		return "12/12/2001";
	}
	
	public String rotacao()
	{
		return "120 km";
	}
	
}

class CarroMaisEspecifico extends CarroEspecifico
{
	public String modelo()
	{
		return "Punto 1.0";
	}
	
	public  String anoFabricacao()
	{
		return "12/12/2008";
	}
	
	public String rotacaoEspecifica()
	{
		return "150 km";
	}

}

public class Teste
{
	public static void main(String args[])
	{
		     Carro obj = new CarroEspecifico();  
	         System.out.println(  obj.modelo() );  
	         System.out.println( ((CarroMaisEspecifico) obj).rotacaoEspecifica() );  
	}
}

É pra dar um ClassCastException mesmo, oras! Você criou um “CarroEspecifico” mas quer chamar um método que ele não tem (rotacaoEspecifica).

Você não precisa dar um Cast pra ter certeza de que o método sobreescrito vai ser chamado.
Ele SEMPRE vai ser chamado, vc tem que pensar em referência e instância como duas coisas separadas.

A instância é do tipo CarroMaisEspecifico mas a referência que você está utilizando é do tipo Carro.
Por este motivo o compilador vai apenas “enchergar” os métodos que foram declarados na classe Carro, porém na hora de executa-los ele vai pegar a implementação do seu objeto, ou seja na classe CarroMaisEspecifico.

E você está tendo que fazer um casting pra CarroMaisEspecifico porque a classe Carro não possui tal método. Pra resolver sem casting, basta trocar para

CarroMaisEspecifico obj = new CarroEspecifico();

Não sei se me fiz claro…