É verdade dizer que cada tempo de execução de ligação foi uma ligação durante a compilação estática?

pyskmr:

Eu estou muito confuso sobre a ligação do tema. Como sabemos na ligação estática, o tipo de referência é verificado para determinar a ligação, não o objeto que ele está fazendo referência, e em ligação dinâmica, o tipo de objeto a referência está apontando é levado em consideração.

class A
{
    void show()
    {
        System.out.println("From A");
    }
}
class B extends A
{
    void show()
    {
        System.out.println("From B");
    }
}
class Main
{
    public static void main(String[] quora)
    {
        A a1 = new A();
        A a2 = new B();

        a1.show(); //line 1
        a2.show(); //line 2
    }
}

No exemplo acima, podemos ver durante o tempo de compilação, tanto Linha1 e linha2 vai ser tratada por ligação estática e que vai ligar ao programa de método A-classe (uma vez que o tipo de referência é A). Mas durante a execução, a chamada é resolvido e as ligações line1 para o show método de classe A () e ligações line2 ao ie método B-classe, tipo de objeto ou podemos dizer de ligação dinâmica.

Assim, a minha intenção principal é saber o seguinte.

1. É ligação dinâmica sempre resultados após ligação estática? ou eu estou entendendo alguma coisa errada?

2. Se é verdade, então é verdade dizer cada método é ligado dinamicamente durante o tempo de execução?

3. podemos generalizar isso?

Sweeper:

Basicamente, cada vez que você chamar um método, o compilador tem que descobrir qual a sobrecarga de chamada, com base nos tipos e os argumentos que você passa para o método. Esta é estático vinculativo. Em seguida, em tempo de execução, o tempo de execução vai descobrir qual aplicação da sobrecarga (que já está decidido neste momento) a chamada.

Considerar:

class A
{
    void f(Object o)
    {
        System.out.println("From A");
    }
}
class B extends A
{

    void f(Object o)
    {
        System.out.println("From B (Object)");
    }

    void f(String s)
    {
        System.out.println("From B (String)");
    }
}

E você faz:

A a = new B();
a.f("");

O que acontece? Em tempo de compilação, o compilador escolheu a sobrecarga f(Object)devido ao tipo de aestar A(há apenas um método para escolher!). Em seguida, em tempo de execução, uma vez que a, na verdade, refere-se a uma instância B, Bda implementação da f(Object)sobrecarga é chamado, imprimindo From B (Object). Um equívoco que eu vi é de esperar que a saída seja From B (String). Isso é errado porque o compilador não sabe sobre a existência dessa sobrecarga a.

É ligação dinâmica sempre resultados após ligação estática?

Como podemos ver a partir dos resultados do código acima, a resposta é sim. Estática de ligação acontece em tempo de compilação, ligação dinâmica acontece em tempo de execução, de modo que o ex acontece sempre em primeiro lugar.

Se é verdade, então é verdade dizer cada método é ligado dinamicamente durante o tempo de execução?

Eu não tenho certeza do que você quer dizer com isso, por isso espero que a explicação detalhada acima teria respondido isso já.

Não importa o que, há sempre vai ser obrigatório estático e, em seguida, ligação dinâmica para cada chamada de método?

Sim, mas às vezes esses dois processos pode ir muito rapidamente, porém, porque há muito poucas opções. Você provavelmente não precisa de fazer uma "escolha" na dinâmica de ligação quando a classe que você está chamando o método em uma classe final, não é?