Il sovraccarico è in fase di compilazione del polimorfismo. Davvero?

So sintattica differenza tra modificare e sovraccarico. E so anche che l’override è di run-time di polimorfismo e il sovraccarico è in fase di compilazione del polimorfismo. Ma la mia domanda è: “È sovraccarico è davvero in fase di compilazione polimorfismo? È la chiamata al metodo davvero risolvere in fase di compilazione?”. Per chiarire il mio punto di vista, consideriamo un esempio di classe.

public class Greeter {
    public void greetMe() {
        System.out.println("Hello");
    }

    public void greetMe(String name) {
        System.out.println("Hello " + name);
    }

    public void wishLuck() {
        System.out.println("Good Luck");
    }
}

Dal momento che tutti i metodi greetMe(), greetMe(String name), wishLuck() sono pubbliche e tutti possono essere ignorate(tra cui sovraccarica), giusto? Per esempio,

public class FancyGreeter extends Greeter {
    public void greetMe() {
        System.out.println("***********");
        System.out.println("*  Hello  *");
        System.out.println("***********");
    }
}

Ora, si consideri il seguente frammento:

Greeter greeter = GreeterFactory.getRandomGreeter();
greeter.greetMe();

Il getRandomGreeter() metodo restituisce un valore casuale Greeter oggetto. Si può restituire un oggetto di Greeter, o una qualsiasi delle sue sottoclassi, come FancyGreeter o GraphicalGreeter o qualsiasi altro. Il getRandomGreeter() creare oggetti utilizzando new o caricare dinamicamente il file di classe e la creazione di oggetti utilizzando la reflection(credo sia possibile con la riflessione) o in qualsiasi altro modo che è possibile. Tutti questi metodi di Greeter possono o non possono essere ignorate in sottoclassi. In modo che il compilatore non ha modo di sapere se un particolare metodo(sovraccarico o non) è sottoposto a override. Giusto? Inoltre, dice wikipedia su Funzioni virtuali:

In Java, tutti i non-metodi statici sono di default “funzioni virtuali”.
Solo i metodi contrassegnati con la parola chiave finale, che non può essere ignorato,
insieme con i metodi privati, che non sono ereditate, non virtuale.

Poiché, funzioni virtuali sono risolto a tempo di esecuzione utilizzando il metodo dinamico di spedizione, e dal momento che tutti non privato, non finale di metodi virtuali(se sovraccarico o non), deve essere risolto a tempo di esecuzione. Giusto?

Quindi, Come si può sovraccaricare ancora essere risolto a tempo di compilazione? Oppure, c’è qualcosa che ho frainteso, o mi manca?

InformationsquelleAutor Jomoos | 2011-12-02

 

5 Replies
  1. 12

    Metodi di overload può ancora essere sottoposto a override, se questo è ciò che si chiede.

    Metodi di overload sono come diverse famiglie, anche se condividono lo stesso nome. Il compilatore in modo statico sceglie uno di famiglia la firma, e quindi in fase di esecuzione viene inviato il metodo più specifico nella gerarchia di classi.

    Che è, il metodo di spedizione è eseguita in due fasi:

    • Il primo è fatto a tempo di compilazione con la statica informazioni disponibili, il compilatore emette un call per la firma che corrisponde meglio alle vostre attuali parametri di metodo tra la lista dei metodi di overload in dichiarato il tipo di oggetto di cui il metodo è invocato.
    • Il secondo passo è eseguito in fase di esecuzione, data la firma del metodo che dovrebbe essere chiamato (passaggio precedente, ricordate?), la JVM di spedizione è la più concreta versione sostituita del tipo effettivo dell’oggetto ricevente.

    Se il metodo di argomenti che i tipi non sono covariante a tutti, il sovraccarico è equivalente ad avere metodi nomi alterati in fase di compilazione, perché sono effettivamente diversi metodi, la JVM non mai la spedizione in modo intercambiabile, a seconda del tipo di ricevitore.

    • So che i metodi di overload può essere ridefinito. Ma come fai a tempo di compilazione polimorfismo applicata ai metodi di overload? Inoltre, essi possono essere sostituiti, e quindi deve essere risolto a tempo di esecuzione. Giusto?
    • Potresti spiegare questa cosa di famiglia più?
    • Jomoos: il compilatore può ancora risolvere dei metodi di overload di scegliere in fase di compilazione, perché l’elenco degli argomenti che non possono cambiare con l’override. In fase di runtime, la JVM solo risolve da cui oggetto deve chiamare questa “versione” (selezionato dal sovraccarico versioni in fase di compilazione del metodo. Scusa i termini profani, non ho un profondo CS sfondo.
  2. 14

    Ogni ‘Greeter’ classe ha 3 metodi virtuali: void greetMe(), void greetMe(String), e void wishLuck().

    Quando si chiama greeter.greetMe() il compilatore è in grado di capire che uno dei tre metodi virtuali dovrebbe essere chiamato dal metodo di firma – ie. il void greetMe() in quanto non accetta argomenti. Specifiche di attuazione del void greetMe() viene chiamato il metodo dipende dal tipo di greeter istanza, ed è stato risolto a tempo di esecuzione.

    Nel tuo esempio è banale per il compilatore per capire quale metodo di chiamata, dal momento che il metodo firme sono tutte completamente diverse. Un po ‘ migliore esempio per mostrare il ‘tempo di compilazione polimorfismo’ concetto potrebbe essere come segue:

    class Greeter {
        public void greetMe(Object obj) {
            System.out.println("Hello Object!");
        }
    
        public void greetMe(String str) {
            System.out.println("Hello String!");
        }
    }

    Utilizzo di questa classe greeter darà i seguenti risultati:

    Object obj = new Object();
    String str = "blah";
    Object strAsObj = str;
    
    greeter.greetMe(obj); //prints "Hello Object!"
    greeter.greetMe(str); //prints "Hello String!"
    greeter.greetMe(strAsObj); //prints "Hello Object!"

    Il compilatore scegliere il metodo più specifico corrispondenza con il tipo in fase di compilazione, che è il motivo per cui il 2 ° esempio funziona e chiama il void greetMe(String) metodo.

    L’ultima chiamata è quella più interessante: Anche se il run-time tipo di strAsObj è String, è stato etichettato come un Object in modo che il compilatore vede. Così, la corrispondenza più vicina il compilatore è in grado di trovare per quella chiamata è il void greetMe(Object) metodo.

  3. 10

    Che cosa è il polimorfismo?

    Acc. a me: se un oggetto può essere rappresentato in più forme, che entità è detto ad esporre il polimorfismo.

    Ora, consente di applicare questa definizione di costrutti Java:

    1) l’overload dell’Operatore è tempo di compilazione polimorfismo.

    Per esempio, + operatore può essere utilizzato per aggiungere due numeri O per concatenare due stringhe. e ‘ un esempio di polimorfismo severamente dicendo di compilazione polimorfismo.

    2) l’overload del Metodo è tempo di compilazione polimorfismo.

    Per esempio, un metodo con lo stesso nome possono avere più di un implemntations. è anche un tempo di compilazione di polimorfismo.

    It's compile-time because before execution of program compiler decides the flow of program i.e which form will be used during run-time.

    3) Metodo di override è di run-time di polimorfismo.

    Per esempio, un metodo con la stessa firma può avere più di uno i implemenations. è un tempo di esecuzione di polimorfismo.

    4) classe di Base da utilizzare al posto della classe derivata è tempo di esecuzione polimorfismo.

    Per esempio, un interface di riferimento può scegliere qualsiasi sviluppatore.

    It's run-time because the flow of program can't be known before execution i.e. only during run-time it can be decided that which form will be used.

    Spero che si allontana un po’.

  4. 3

    Sovraccarico, rispetto a questo, significa che il tipo di funzione è staticamente determinato in fase di compilazione come contrasto dinamico di spedizione.

    Di ciò che realmente accade dietro le quinte è che, per un metodo che si chiama “pippo” con i tipi “A” e “B” i due metodi vengono creati (“foo_A” e “foo_B”). Quale di questi è quello di essere chiamato è determinato a tempo di compilazione (foo((A) object) o foo((B) object) risultato in foo_A di essere chiamato o foo_B). Quindi, in un certo senso, questo è in fase di compilazione polimorfismo, anche se il vero metodo (cioè che l’attuazione della gerarchia di classe a prendere) è determinato in fase di runtime.

  5. 0

    Ho forti obiezioni a chiamata l’overload del metodo di compilazione polimorfismo.

    Sono d’accordo che l’overload del metodo è statica(di compilazione), ma non ho visto il polimorfismo in.

    Ho provato a mettere la mia opinione la mia domanda per ottenere chiarimenti. è possibile fare riferimento questo link.

Lascia un commento