Fiquei com duvida no que seria binder de variável e de método em tempo de compilação, não consegui achar nada a respeito que pudesse sanar minha duvida.
Você está vendo a versão anterior da nova experiência da Alura que estamos preparando para você. Em breve, ela ganha uma identidade visual novinha totalmente pensada em potencializar seus estudos!
Solucionado
Fiquei com duvida no que seria binder de variável e de método em tempo de compilação, não consegui achar nada a respeito que pudesse sanar minha duvida.
Olá Pedro tudo bem?
Não sei se é sobre isso que você esta procurando, mas...
Em java temos dois tipos de Bindings: Static Binding e Dynamic Binding.
O Dynamic Binding acontecem quando estamos usando algo que pode ser sobrescrito (por exemplo quando usamos polimorfismo)
Quando estamos sobrescrevendo um método ( por exemplo), em função da referencia que estivermos usando no momento (em tempo de execução) a JVM decide qual método deve ser executado.
class A {
public void hello(){
System.out.println("A, hello");
}
}
class B extends A {
public void hello(){
System.out.println("B, hello");
}
}
class Test {
public static void main(String[] args){
A fist = new A();
A second = new B();
first.hello();
second.hello();
}
}O Resultado é:
A, hello
B, helloNesse caso como o first é uma referência do tipo A quando invocamos o método first.hello() a JVM invoca o método que foi definido na classe A.
E no caso do second, ele é uma referência do tipo B (por mais que a declaração estejamos atribuindo a referência (new B()) para um tipo A, a referência continua sendo do tipo B).
Ao executarmos o método second.hello() a JVM invoca o método que foi definido na classe B.
Como a JVM precisa saber qual a referência do objeto que ela está lidando no momento em que vai invocar um método (runtime), o binding só pode ser feito em runtime.
O Static Binding acontecem por exemplo quando temos métodos private, static e/ou final.
Como nenhum desses modificadores de acessos podem ser sobrescritos (overriden) então o bind entre a referencia para corpo do método (reference method body) e a chamada do método é feito em tempo de execução.
class A {
public static void hello() {
System.out.println("A, hello");
}
}
class B extends A {
public static void hello() {
System.out.println("B, hello");
}
}
class Test {
public static void main(String[] args){
A first = new A();
A second = new B();
first.hello();
second.hello();
}
}O resultado é:
A, hello
A, helloNesse caso quando informamos que o tipo dos objetos são A e o método é static (no caso não pode ser sobrescrito). Em tempo de compilação ele faz o bind da chamada do método (fisrt.hello() e second.hello()) com o método declarado na classe A.
Dessa forma em tempo de execução a JVM não precisa ficar verificando qual é a referencia do objeto para saber qual o método deve chamar. Pois o binding ocorre pelo tipo e não pela referência.
Poderíamos ter declarado a classe Test da seguinte forma:
class Test {
public static void main(String[] args){
A first = new A();
B second = new B();
first.hello();
second.hello();
}
}Nesse caso o resultado sería:
A, hello
B, helloMas pelo fato do método ser static o binding ainda aconteceria em tempo de compilação.
Resumindo: Os Static Bindings acontece em tempo de compilação (para tudo o que não pode ser sobrescrito), enquanto os Dynamic Bindings acontecem em tempo de execução (em função da referencia do objeto que se temo no momento).
Espero ter ajudado
[]s