objets gauche et droite sont évalués / résolus lors de l'exécution ou la compilation?

Tim Daiu:

Se référant à un exercice comptable ...

Avoir le code suivant ..

Left left = createLeftInstance ();
Right right = createRightInstance ();

... et en tenant compte du fait que les deux méthodes ci-dessus mentionnées peuvent retourner exemple de toutes les sous-classes de gauche et de droite, en Java à l'appel de la méthode suivante ...

left.invoke (right);

comment est résolu:

• A) se basant sur le type d'exécution de gauche et de compilation de droit
• B) se basant sur le type de compilation de gauche et de droite d'exécution
• C) se basant sur le type de compilation de gauche et de compilation de droit
• D) se basant sur le type d'exécution de gauche et de droite d'exécution

peter.petrov:

A) est la bonne réponse ici.

Le code suivant montre que.

    public class Main001 {

        public static void main(String[] args) {
            A right = createRightInstance();
            B left = createLeftInstance();

            left.invoke(right);
            System.out.println("Done!!!");
        }

        public static B createLeftInstance() {
            return new B2();
        }

        public static A createRightInstance() {
            return new A2();
        }

    }

    class A{

    }

    class A1 extends A{

    }

    class A2 extends A1{

    }

    class B{
        public void invoke(A x) {
            System.out.println("Invoking method A on B with argument " + x.getClass().getName());
        }
        public void invoke(A1 x) {
            System.out.println("Invoking method A1 on B with argument " + x.getClass().getName());
        }
        public void invoke(A2 x) {
            System.out.println("Invoking method A2 on B with argument " + x.getClass().getName());
        }
    }

    class B1 extends B{
        public void invoke(A x) {
            System.out.println("Invoking method A on B1 with argument " + x.getClass().getName());
        }
        public void invoke(A1 x) {
            System.out.println("Invoking method A1 on B1 with argument " + x.getClass().getName());
        }
        public void invoke(A2 x) {
            System.out.println("Invoking method A2 on B1 with argument " + x.getClass().getName());
        }

    }

    class B2 extends B1{
        public void invoke(A x) {
            System.out.println("Invoking method A on B2 with argument " + x.getClass().getName());
        }
        public void invoke(A1 x) {
            System.out.println("Invoking method A1 on B2 with argument " + x.getClass().getName());
        }
        public void invoke(A2 x) {
            System.out.println("Invoking method A2 on B2 with argument " + x.getClass().getName());
        }
    }

Cet exemple imprime

Invoking method A on B2 with argument A2
Done!!!

ces moyens A) est la réponse correcte.

Pourquoi est-ce que cela signifie que?

Eh bien ... parce que:
1) une méthode de la classe B2 est invoquée (comme la sortie dit) et B2 est le type d'exécution de left(le type de compilation de leftest B).
2) un procédé de paramètre A est invoqué (note que A est du type de la compilation right), même si le type d'exécution de rightest A2. Type de Compile de temps rightest juste le type qui rightest déclaré par exemple A. Type d' exécution de rightest le type réel de l'argument A2 par exemple (voir la sortie, il est dit with argument A2là - bas).