A diferença entre vinculação estática e dinâmica em Java

1. Vinculação estática em Java
2. Exemplo de vinculação estática em Java
3. Vinculação dinâmica em Java
4. Exemplo de vinculação dinâmica em Java
5. Vinculação estática e vinculação dinâmica em Java

Este tutorial apresenta a diferença entre ligação estática e ligação dinâmica em Java e lista alguns códigos de exemplo para guiá-lo no tópico.

Vinculação é vincular uma chamada de método à implementação do método e tem dois tipos: estático e dinâmico. De acordo com o polimorfismo, um objeto pode ter muitas formas, e essas formas podem ser resolvidas em tempo de compilação ou tempo de execução.

A vinculação estática ocorre quando a chamada do método é vinculada à implementação do método em tempo de compilação. A vinculação dinâmica ocorre quando a vinculação ocorre durante o tempo de execução. Vamos aprender mais sobre esses dois tipos de vinculação e examinar alguns exemplos.

Vinculação estática em Java

Conforme discutido acima, Static Binding é a vinculação que ocorre durante o tempo de compilação. Também é conhecido como Early Binding porque ocorre durante o próprio tempo de compilação.

No caso de Static Binding, o compilador sabe exatamente qual implementação do método usar. Ele usa as informações de tipo ou classe para vinculação; a sobrecarga de método é um exemplo de vinculação estática.

Observe que todos os métodos estáticos, finais e privados usam Static Binding porque as classes filhas não podem substituir os métodos estáticos, finais e privados. O compilador sabe em tempo de compilação qual implementação de método usar. Como o compilador sabe que os métodos da classe pai não podem ser substituídos, ele sempre usa a implementação da classe pai do método.

Além disso, a vinculação estática também tem um desempenho melhor, pois envolve menos sobrecarga.

Exemplo de vinculação estática em Java

No código abaixo, a classe escolar tem um método estático ringBell(), e essa classe é estendida por Classroom. A Classroom também possui um método ringBell().

Como o método ringBell() é estático, o compilador apenas verifica o tipo de classe e não considera a classe de objeto atribuída. Assim, quando uma classe School é utilizada para criar um objeto de Classroom(School s2 = new Classroom()), considera-se a implementação da classe School e não a classe Classroom.

class School {
  public static void ringBell() {
    System.out.println("Ringing the school bell...");
  }
}
class Classroom extends School {
  public static void ringBell() {
    System.out.println("Ringing the classroom bell...");
  }
}
public class Main {
  public static void main(String[] args) {
    School s1 = new School(); // Type is School
    s1.ringBell();
    Classroom c1 = new Classroom(); // Type is Classroom
    c1.ringBell();
    School s2 = new Classroom(); // Type is School
    s2.ringBell();
  }
}

Produção:

Ringing the school bell...
Ringing the classroom bell...
Ringing the school bell...

Vinculação dinâmica em Java

A vinculação dinâmica resolve a vinculação em tempo de execução porque o compilador não sabe qual implementação usar em tempo de compilação.

Também é conhecido como Late Binding porque a vinculação é resolvida em um estágio posterior durante o tempo de execução e não durante o tempo de compilação. A vinculação dinâmica também usa o objeto para vinculação e não o tipo ou classe; a substituição de método é um exemplo de vinculação dinâmica.

Exemplo de vinculação dinâmica em Java

No código abaixo, o método ringBell() não é estático, então a substituição ocorrerá. O compilador não sabe qual implementação do método ringBell() deve ser usada, então a ligação é resolvida em tempo de execução.

Em tempo de execução, o objeto é considerado e não o tipo que foi usado para criá-lo. Assim, quando se utiliza uma classe School para criar um objeto de Classroom, considera-se a implementação da classe Classroom e não a classe School.

class School {
  public void ringBell() {
    System.out.println("Ringing the school bell...");
  }
}
class Classroom extends School {
  @Override
  public void ringBell() {
    System.out.println("Ringing the classroom bell...");
  }
}
public class Main {
  public static void main(String[] args) {
    School s1 = new School(); // Type is School and object is of School
    s1.ringBell();
    Classroom c1 = new Classroom(); // Type is Classroom and object is of Classroom
    c1.ringBell();
    School s2 = new Classroom(); // Type is School and object is of Classroom
    s2.ringBell();
  }
}

Produção:

Ringing the school bell...
Ringing the classroom bell...
Ringing the classroom bell...

Vinculação estática e vinculação dinâmica em Java

A vinculação estática é a conexão da chamada do método à implementação do método em tempo de compilação. Por outro lado, Dynamic Binding é a conexão da chamada do método à implementação do método em tempo de execução.

Conhecer essas duas técnicas é importante para entender o conceito de polimorfismo. A vinculação estática é usada por métodos estáticos, finais e privados; essa ligação entra em ação no caso de métodos sobrecarregados. A Ligação Dinâmica é usada para métodos virtuais (por padrão, virtual em Java) e usada para ligar métodos substituídos.