Como o Java faz a leitura desse cast? sendo que é mais de um? como um pode afetar o outro no processo até chegar atribuição final?
D d = (D) (Y) (B) new D();
Como o Java faz a leitura desse cast? sendo que é mais de um? como um pode afetar o outro no processo até chegar atribuição final?
D d = (D) (Y) (B) new D();
O Java vai tentar fazer cast de D para B => OK, D extends B
e depois
D para Y => erro, D não extends Y
Por lógica a sequencia não seria assim?
Converter D para B, ok? prossegue
Converter B para Y...
converter Y para D
Fazendo uns exercícios o resultado
class Veiculo{}
class Carro extends Veiculo{}
class Moto extends Veiculo{}
class CarroAutomatico extends Carro{}
class MotoAutomatica extends Moto{}
public class Main
{
public static void main(String[] args) {
Carro c = (Carro) (MotoAutomatica) (CarroAutomatico) new Carro();
}
}
Main.java:10: error: incompatible types: CarroAutomatico cannot be converted to MotoAutomatica
Carro c = (Carro) (MotoAutomatica) (CarroAutomatico) new Carro();
^
1 error
Ele não comparou Carro com 'CarroAutomatico', depois Carro com 'MotoAutomatica', mas sim, como eu descrevi acima.
Estou com o raciocínio certo?
Cenário de up-casting:
interface Z {}
interface W {}
interface Y extends Z, W {}
class B {}
class C extends B implements Y {}
class D extends B implements Z, W {}
class E extends C {}
class A {
public static void main(String[] args) {
D d = (D) (Y) (B) new D();
}
}
Exception in thread "main" java.lang.ClassCastException: class com.sensedia.apihorus.D cannot be cast to class com.sensedia.apihorus.Y
Existem dois tipos de Cast em java; up-casting e down-casting.
Up-casting é quando você converte um objeto do tipo especifico para ser um mais genérico (String para Object, por exemplo); você está projetando "para cima" a árvore de herança. O benefício do up-casting é que o compilador é capaz de determinar, em tempo de compilação, se o cast é legal.
Down-casting é quando você converte um objeto mais genérico para ser um objeto mais especifico (Object -> String, por exemplo); O compilador não sabe, em tempo de compilação, se o downcast terá êxito. Por causa disso, um down-cast pode lançar uma exceção em tempo de execução.