Java - Evaluatie van bewerkingen

Tijdens gebruik Java Om programma's te maken die rekenkundige uitdrukkingen dragen, moeten we vaak formules uit de echte wereld overbrengen om onze berekeningen te verkrijgen, maar dit is misschien niet zo direct als het lijkt, zelfs als we alle operatoren hebben.
Er zijn bewerkingen die met een hogere prioriteit worden uitgevoerd dan andere wanneer ze in een uitdrukking staan, dus het is belangrijk om ze te kennen, zodat we om deze reden geen foutieve berekeningen krijgen.
Uitdrukkingen evalueren
Zoals we hadden gezegd, hebben we een prioriteitsvolgorde om de operaties uit te kunnen voeren, dit betekent dat een operatie die op de een of andere manier wordt voorgesteld ons misschien een resultaat kan geven dat niet door ons wordt verwacht en ons een fout kan maken in onze programma.
Om dit soort problemen te voorkomen, laten we in de volgende afbeelding het volgende voorbeeld bekijken waarin we een bewerking van de echte wereld naar Java en zodat we de prioriteiten van de bewerkingen in een uitdrukking:

Zoals we zien gebruiken we de verschillende Java-operators om een ​​equivalent vast te stellen van de eerste uitdrukking die we uit de echte wereld nemen.
Als u eenmaal in Java bent, heeft de taal zijn eigen regels om de prioriteit van bewerkingen te evalueren en toe te passen, de volgorde zou als volgt zijn:

• De binnenste haakjes, dan de buitenste.
• vermenigvuldigingen
• Divisies
• Sommen of toevoegingen
• Aftrekken of aftrekken

Zoals we kunnen zien, komt dit in grote mate overeen met wat we in de basisrekenkunde behandelen, in het geval van de bewerking die we zojuist hebben getoond, laten we eens kijken hoe het in Java zou worden geëvalueerd in de volgende afbeelding:

Zoals we kunnen zien, volgen we de volgorde die we hadden aangegeven met betrekking tot de bewerkingen, maar we kunnen een extra gedrag opmerken, de bewerkingen worden van links naar rechts geëvalueerd, dat wil zeggen, als twee bewerkingen dezelfde prioriteit hebben, de bewerking die het dichtst bij de left wordt eerst uitgevoerd. , we kunnen dit zien in het voorbeeld in de punten 2 en 3 dat zijn twee vermenigvuldigingen en in de punten 4 en 5 waar zijn twee toevoegingen.
Hiermee weten we dus al hoe we de vertaling van rekenkundige bewerkingen naar Java uitvoeren.
We gaan een praktisch voorbeeld uitvoeren waarmee we kunnen gebruiken wat we hebben geleerd, we gaan een programma dat converteert van graden Fahrenheit naar graden Celsius.
Laten we eerst kijken naar de originele formule om deze berekening uit te voeren:

Nu hebben we hier de code waarmee we de conversie kunnen doen:

 importeer Java.util.Scanner; public class FahrenheitToCelsius {public static void main (String [] args) {Scannerinvoer = nieuwe scanner (System.in); System.out.print ("Voer de Fahrenheit-graden in:"); dubbele fahrenheit = invoer.nextDouble (); // We doen de conversie dubbele celsius = (5.0 / 9) * (fahrenheit - 32); System.out.println ("***********************************"); System.out.println ("Fahrenheit" + fahrenheit + "is" + celsius + "in Celsius"); System.out.println ("***********************************"); }} 

Nu zien we het resultaat van ons programma:

We kunnen nu de conversie doen, als we de formule zien dubbele celsius = (5,0 / 9) * (fahrenheit - 32); hier voeren we eerst de bewerkingen tussen haakjes uit, daarna doen we de vermenigvuldiging van beide resultaten.
Hiermee ronden we deze tutorial af, waarmee we ervoor kunnen zorgen dat we al zonder problemen complexere formules kunnen overzetten naar onze Java-programma's.Vond je deze Tutorial leuk en heb je eraan geholpen?Je kunt de auteur belonen door op deze knop te drukken om hem een ​​positief punt te geven