O que seria binder?

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.

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, hello

Nesse 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.

Static Binding

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, hello

Nesse 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, hello

Mas 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