Chiamare un metodo su un nuovo oggetto in Java senza parentesi: violazione dell'ordine delle operazioni?

Question

In base a this table of Java operator precedence and associativity, l'accesso membro ha precedenza più elevata rispetto all'operatore new.

Tuttavia, data una classe myClass e una funzione di membro non statica myFunction, la seguente riga di codice è valido:

new myClass().myFunction();

Se . viene valutata prima new, come può essere eseguito questa linea? In altre parole, perché non sono necessarie le parentesi?

(new myClass()).myFunction();

La mia ipotesi è che, poiché () condivide la precedenza con ., il myClass() viene valutata prima, e così il compilatore sa ancora prima di valutare la parola chiave new che il costruttore myClass con i parametri a zero viene chiamato. Tuttavia, questo sembra ancora implicare che la prima riga dovrebbe essere identica a new (myClass().myFunction());, che è non il caso.

Answer 1

Ciò è dovuto al modo in cui è definito il grammar linguaggio Java. La precisione degli operatori entra in gioco proprio quando la stessa sequenza lessicale può essere analizzata in due modi diversi, ma questo non è il caso.

Perché?

Poiché l'allocazione viene definita in:

Primary: 
    ... 
    new Creator 

mentre il metodo di chiamata è definito in:

Selector: 
    . Identifier [Arguments] 
    ... 

ed entrambi sono utilizzati qui:

Expression3: 
    ... 
    Primary { Selector } { PostfixOp } 

così accade che

new myClass().myFunction(); 

viene analizzato come

  Expression 
      | 
      | 
    ---------+-------- 
    |    | 
    |    | 
    Primary  Selector 
    |    | 
    |    | 
---+---   ... 
|  | 
new Creator 

Quindi non c'è scelta in base alla priorità, perché il Primary viene ridotta prima. Presente che per la particolare situazione come

new OuterClass.InnerClass() 

il nome della classe è in realtà analizzato prima che l'operatore new e ci sono regole per gestire questo caso davvero. Controlla la grammatica se ti piace vederli.

Answer 2

Non sono d'accordo con la conclusione tratta dal diagramma di Jack. Quando una grammatica è scritta, i suoi non terminali e la struttura sono progettati per implementare la precedenza e l'associatività della lingua descritta. Ecco perché il classico BNF per le espressioni introduce il "termine" e il "fattore" non-terminale - per applicare la normale moltiplicazione prima dell'aggiunta della precedenza dell'aritmetica.

Quindi il fatto che "Primario -> nuovo Creatore" e "Espressione -> Selettore principale" nella grammatica significhi che "nuovo Creatore" è a un livello di precedenza più alto di "Selettore primario".

Mi sembra che la grammatica sia la prova che la tabella di precedenza e associatività dell'operatore Java non è corretta.