Java Language
Uitdrukkingen

Invoering

Opmerkingen

Voorrang operator

Wanneer een uitdrukking meerdere operatoren bevat, kan deze mogelijk op verschillende manieren worden gelezen. De wiskundige uitdrukking 1 + 2 x 3 kan bijvoorbeeld op twee manieren worden gelezen:

1. Voeg 1 en 2 en vermenigvuldig het resultaat met 3 . Dit geeft het antwoord 9 . Als we haakjes toevoegen, ziet dit eruit als ( 1 + 2 ) x 3 .
2. Voeg 1 aan het resultaat van vermenigvuldiging 2 en 3 . Dit geeft het antwoord 7 . Als we haakjes toevoegen, ziet dit eruit als 1 + ( 2 x 3 ) .

In de wiskunde is de conventie de uitdrukking op de tweede manier te lezen. De algemene regel is dat vermenigvuldiging en deling plaatsvinden vóór optellen en aftrekken. Wanneer meer geavanceerde wiskundige notatie wordt gebruikt, is de betekenis ofwel "vanzelfsprekend" (voor een getrainde wiskundige!), Of worden haakjes toegevoegd om het ondubbelzinnig te maken. In beide gevallen hangt de effectiviteit van de notatie om betekenis over te brengen af van de intelligentie en gedeelde kennis van de wiskundigen.

Java heeft dezelfde duidelijke regels voor het lezen van een uitdrukking, gebaseerd op de prioriteit van de operatoren die worden gebruikt.

In het algemeen wordt aan elke operator een prioriteitswaarde toegekend; zie onderstaande tabel.

Bijvoorbeeld:

  1 + 2 * 3

De prioriteit van + is lager dan de prioriteit van * , dus het resultaat van de uitdrukking is 7, niet 9.

¹ Prioriteit van Lambda-expressie is complex, omdat het ook kan optreden na een cast of als het derde deel van de voorwaardelijke ternaire operator.

Constante uitdrukkingen

Een constante expressie is een expressie die een primitief type of een tekenreeks oplevert en waarvan de waarde tijdens het compileren tot een letterlijke waarde kan worden geëvalueerd. De uitdrukking moet worden geëvalueerd zonder een uitzondering te maken en moet alleen uit het volgende bestaan:

• Primitieve en String literals.

• Type cast naar primitieve typen of String .

• De volgende unaire operatoren: + , - , ~ en ! .

• De volgende binaire operatoren: * , / , % , + , - , << , >> , >>> , < , <= , > , >= , == != , & , ^ , | , && en || .

• De ternaire voorwaardelijke operator ? : .

• Haakjes constante uitdrukkingen.

• Eenvoudige namen die verwijzen naar constante variabelen. (Een constante variabele is een variabele die als final aangegeven, waarbij de initialisatie-uitdrukking zelf een constante uitdrukking is.)

• Gekwalificeerde namen van het formulier <TypeName> . <Identifier> die verwijzen naar constante variabelen.

Merk op dat de bovenstaande lijst ++ en -- , de toewijzingsoperators, class en instanceof , methodeaanroepen en verwijzingen naar algemene variabelen of velden uitsluit .

Constante expressies van het type String resulteren in een "geïnterneerde" String en drijvende-kommabewerkingen in constante expressies worden geëvalueerd met FP-strikte semantiek.

Gebruikt voor constante uitdrukkingen

Constante expressies kunnen overal worden gebruikt waar een normale expressie kan worden gebruikt. Ze hebben echter een speciale betekenis in de volgende contexten.

Constante uitdrukkingen zijn vereist voor hoofdetiketten in schakelinstructies. Bijvoorbeeld:

switch (someValue) {
case 1 + 1:            // OK
case Math.min(2, 3):   // Error - not a constant expression
    doSomething();
}

Als de uitdrukking aan de rechterkant van een toewijzing een constante uitdrukking is, kan de toewijzing een primitieve vernauwing omzetten. Dit is toegestaan op voorwaarde dat de waarde van de constante uitdrukking binnen het bereik van het type aan de linkerkant ligt. (Zie JLS 5.1.3 en 5.2 ) Bijvoorbeeld:

byte b1 = 1 + 1;             // OK - primitive narrowing conversion.
byte b2 = 127 + 1;           // Error - out of range
byte b3 = b1 + 1;            // Error - not a constant expession
byte b4 = (byte) (b1 + 1);   // OK

Wanneer een constante uitdrukking wordt gebruikt als de voorwaarde in een do , while of for , dan beïnvloedt dit de leesbaarheidsanalyse. Bijvoorbeeld:

while (false) {
    doSomething();           // Error - statenent not reachable
}
boolean flag = false;
while (flag) {
    doSomething();           // OK
}

(Merk op dat dit niet van toepassing is op if instructies. De Java-compiler staat het then of else blok van een if instructie toe onbereikbaar te zijn. Dit is het Java-analoog van voorwaardelijke compilatie in C en C ++.)

Ten slotte worden static final velden in een klasse of interface met initialisatie van constante expressie enthousiast geïnitialiseerd. Het is dus gegarandeerd dat deze constanten worden waargenomen in de geïnitialiseerde status, zelfs wanneer er een cyclus is in de grafiek voor de initialisatie van de klasse-initialisatie.

Raadpleeg JLS 15.28 voor meer informatie . Constante uitdrukkingen .

Order voor expressie-evaluatie

Java-expressies worden geëvalueerd volgens de volgende regels:

• Operanden worden van links naar rechts geëvalueerd.
• De operanden van een operator worden vóór de operator geëvalueerd.
• Operators worden geëvalueerd volgens operatorprioriteit
• Argumentenlijsten worden van links naar rechts geëvalueerd.

Eenvoudig voorbeeld

In het volgende voorbeeld:

int i = method1() + method2();

de volgorde van evaluatie is:

1. De linker operand van = operator wordt geëvalueerd naar het adres van i .
2. De method1() van de operator + ( method1() ) wordt geëvalueerd.
3. De juiste operand van de operator + ( method2() ) wordt geëvalueerd.
4. De bewerking + wordt geëvalueerd.
5. De bewerking = wordt geëvalueerd, waarbij het resultaat van de toevoeging wordt toegewezen aan i .

Merk op dat als de effecten van de aanroepen waarneembaar zijn, u zult kunnen waarnemen dat de aanroep van method1 plaatsvindt vóór de aanroep van method2 .

Voorbeeld met een operator die een bijwerking heeft

In het volgende voorbeeld:

int i = 1;
intArray[i] = ++i + 1;

de volgorde van evaluatie is:

1. De linker operand van = operator wordt geëvalueerd. Dit geeft het adres van intArray[1] .
2. De pre-toename wordt geëvalueerd. Dit voegt 1 aan i en resulteert in 2 .
3. De rechterhand operand van de + wordt geëvalueerd.
4. De bewerking + wordt geëvalueerd als: 2 + 1 -> 3 .
5. De = bewerking wordt geëvalueerd, waarbij 3 wordt toegewezen aan intArray[1] .

Merk op dat aangezien de linker operand van de = eerst wordt geëvalueerd, deze niet wordt beïnvloed door de bijwerking van de ++i subexpressie.

Referentie:

• JLS 15.7 - Evaluatieorder

Basisprincipes van expressie

Uitdrukkingen in Java zijn de primaire constructie voor het uitvoeren van berekeningen. Hier zijn enkele voorbeelden:

1                 // A simple literal is an expression
1 + 2             // A simple expression that adds two numbers
(i + j) / k       // An expression with multiple operations
(flag) ? c : d    // An expression using the "conditional" operator
(String) s        // A type-cast is an expression
obj.test()        // A method call is an expression
new Object()      // Creation of an object is an expression
new int[]         // Creation of an object is an expression

Over het algemeen bestaat een uitdrukking uit de volgende vormen:

• Uitdrukkingsnamen die bestaan uit:
  • Eenvoudige identificatiegegevens; bijvoorbeeld someIdentifier
  • Gekwalificeerde identificatiegegevens; bijv. MyClass.someField
• Primaries die bestaan uit:
  • literals; bijv. 1 , 1.0 , 'X' , "hello" , false en null
  • Klasse letterlijke uitdrukkingen; bijv. MyClass.class
  • this en <TypeName> . this
  • Haakjes uitdrukkingen; bijv. ( a + b )
  • Klasse-instantie uitdrukkingen; bijv. new MyClass(1, 2, 3)
  • Uitdrukkingen voor het maken van arrayinstanties; bijv. new int[3]
  • Veldtoegangsuitdrukkingen; bijv. obj.someField of this.someField
  • Matrix toegangsuitdrukkingen; bijv. vector[21]
  • Aanroepingen van methoden; bijv. obj.doIt(1, 2, 3)
  • Referentiemethoden (Java 8 en hoger); bijv. MyClass::doIt
• Unaire operatoruitdrukkingen; bijvoorbeeld !a of i++
• Binaire operator uitdrukkingen; bijv. a + b of obj == null
• Ternary operator expressies; bijv. (obj == null) ? 1 : obj.getCount()
• Lambda-uitdrukkingen (Java 8 en hoger); bijv. obj -> obj.getCount()

De details van de verschillende uitdrukkingsvormen zijn te vinden in andere onderwerpen.

• Het onderwerp Operators heeft betrekking op unaire, binaire en ternaire operatoruitdrukkingen.
• Het onderwerp Lambda-uitdrukkingen heeft betrekking op lambda-uitdrukkingen en uitdrukkingen voor methodeverwijzingen.
• Het onderwerp Klassen en objecten behandelt uitdrukkingen voor het maken van klasseninstanties.
• Het onderwerp Arrays heeft betrekking op matrixtoegangsuitdrukkingen en expressies voor het maken van matrixinstanties.
• Het onderwerp Letterlijk behandelt de verschillende soorten letterlijke uitdrukkingen.

Het type expressie

In de meeste gevallen heeft een uitdrukking een statisch type dat kan worden bepaald tijdens het compileren door te onderzoeken en de subexpressies ervan. Dit worden op zichzelf staande uitdrukkingen genoemd.

(In Java 8 en hoger) kunnen de volgende soorten expressies echter poly-expressies zijn :

• Haakjes uitdrukkingen
• Klasse-instantie creatie-expressies
• Methode aanroep uitdrukkingen
• Methode referentie uitdrukkingen
• Voorwaardelijke uitdrukkingen
• Lambda-uitdrukkingen

Als een expressie een poly uitdrukking, kan het type worden beïnvloed door de expressie van doeltype; dat wil zeggen waarvoor het wordt gebruikt.

De waarde van een expressie

De waarde van een uitdrukking is toewijzing compatibel met het type. De uitzondering hierop is wanneer hoop op vervuiling is opgetreden; bijv. omdat waarschuwingen voor "onveilige conversie" (ten onrechte) zijn onderdrukt of genegeerd.

Expressie verklaringen

In tegenstelling tot veel andere talen, staat Java over het algemeen niet toe dat uitdrukkingen als verklaringen worden gebruikt. Bijvoorbeeld:

public void compute(int i, int j) {
    i + j;   // ERROR
}

Omdat het resultaat van het evalueren van een uitdrukking als niet kan worden gebruikt, en omdat het de uitvoering van het programma op geen enkele andere manier kan beïnvloeden, hebben de Java-ontwerpers het standpunt ingenomen dat een dergelijk gebruik ofwel een fout is, ofwel verkeerd is.

Dit geldt echter niet voor alle uitdrukkingen. Een subset van uitdrukkingen zijn (in feite) legaal als verklaringen. De set bestaat uit:

• Opdrachtuitdrukking, inclusief bewerking-en-wordt- opdrachten.
• Pre- en post-increment- en decrement-expressies.
• Methodeaanroepen ( void of void ).
• Klasse-instantie uitdrukkingen.