Anwendungsmöglichkeiten lokaler `final`-Variablen in Java

Laufzeit-`final`-Variablen

Es ist nicht nötig, daß der Wert einer final-Variablen bereits beim Schreiben des Programms festgelegt wird. Es ist auch erlaubt, daß er erst zur Laufzeit berechnet wird.

Da Zufallszahlen erst beim Ablauf des Programms festgelegt werden, kann der Compiler die Werte der folgenden final-Variablen nicht kennen.

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  {
    final double zufallszahl = java.lang.Math.random();
    final double zufallszahl1 = 2 * java.lang.Math.random();
    final double zufallszahl2 = 
    java.lang.Math.abs( 2 * java.lang.Math.random() - 1 ); 
    java.lang.System.out.println( zufallszahl );
    java.lang.System.out.println( zufallszahl1 );
    java.lang.System.out.println( zufallszahl2 ); }}

Protokoll

0.1281560159794106
1.4425721222173412
0.5132925319782136

Wenn dasselbe Programm erneut gestartet wird, so könnte etwas anderes ausgegeben werden.

Protokoll

0.6256970393263901
1.3939426634532628
0.7474609946328631

Bezüge auf die Zukunft

Der Name »zufallszahl« in dem Programm des vorigen Abschnitts zeigt, daß es möglich ist, sich in einem Programm mit einem Namen auf einen Wert zu beziehen, der erst in der Zukunft festgelegt und bekannt werden wird. (Der Wert des Namens ist beim Schreiben des Programms noch nicht bekannt, sondern wird erst festgelegt werden, wenn das Programm gestartet werden wird.)

Auflösung von Verschachtelungen

Wenn verschachtelte Methodenaufrufe als unübersichtlich erscheinen, können sie durch Einführung einer final-Variablen aufgelöst werden. Jedoch ist es nicht möglich, allgemein zu sagen, welche der beiden Varianten nun besser ist. Falls ein verschachtelter Aufruf schwer verständlich ist, kann die Einführung einer final-Variablen mit einem erklärenden Namen aber wahrscheinlich hilfreich sein.

Verschachtelter Aufruf:

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  {
    java.lang.System.out.println( java.lang.Math.random() ); }}

Protokoll

0.7900126482960118

Aufgelöste Verschachtelung:

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  {
    final double zufallszahl = java.lang.Math.random();
    java.lang.System.out.println( zufallszahl ); }}

Protokoll

0.7900126482960118

Nach der Auflösung der Verschachtelung ist die Reihenfolge der Aktivierung der Programmteile im Quelltext so wie zur Laufzeit: Zuerst wird eine Zufallszahl mit »random« berechnet, dann wird sie mit »println« ausgegeben. In der Version des Programms mit Verschachtelung der Klammernpaare ist der Ablauf genauso, aber das Wort »println« steht im Quelltext vor dem Worte »random«.

Verteilung einer Information an mehrere Stellen

Das folgende Beispiel zeigt, wie ein und derselbe Laufzeitwert mit einer final-Variablen an mehrere Stellen eines Programms transportiert werden kann. Erst dadurch wird es möglich, ein und dieselbe Zufallszahl zweimal hintereinander auszugeben.

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  {
    final double randomNumber = java.lang.Math.random();
    //                |
    //                '----------------------------------.
    //                                                   |                 
    java.lang.System.out.println( randomNumber ); // <---'
                                                  //     |
    java.lang.System.out.println( randomNumber ); // <---'
                                                  }}

Protokoll

0.8840385027765092
0.8840385027765092

Vermeidung unnötiger doppelter Berechnungen

Wenn ein Wert unnötigerweise doppelt berechnet wird, kann die doppelte Berechnung durch Einführung einer final-Variablen vermieden werden.

unnötige doppelte Berechnung:

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  {
    java.lang.System.out.println( java.lang.Math.floor( 2.7 ));
    java.lang.System.out.println( java.lang.Math.floor( 2.7 )); }}

Protokoll

2.0
2.0

einmalige Berechnung:

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  {
    final double floor = java.lang.Math.floor( 2.7 );
    java.lang.System.out.println( floor ); 
    java.lang.System.out.println( floor ); }}

Protokoll

2.0
2.0

Man sieht, daß auch der Name einer Standardmethode, wie »floor«, als Name einer final-Variablen verwendet werden kann, da der Name der Standardmethode durch seine Qualifikation und die Art seiner Verwendung weiterhin vom Namen der final-Variablen unterschieden werden kann.

Das folgende Gegenbeispiel zeigt eine Situation, in welcher der zwiefache Aufruf einer Methode nicht durch einen einmaligen Aufruf ersetzt werden kann, ohne daß sich das Verhalten ändert, weil bei der doppelten Berechnung meist zwei verschiedene Werte ausgegeben werden, während bei der einmaligen Berechnung derselbe Wert doppelt ausgegeben wird.

doppelte Berechnung

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  {
    java.lang.System.out.println( java.lang.Math.random() );
    java.lang.System.out.println( java.lang.Math.random() ); }}

Protokoll

0.4183351679424453
0.3016260599904125

einmalige Berechnung:

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  {
    final double randomNumber = java.lang.Math.random();
    java.lang.System.out.println( randomNumber ); 
    java.lang.System.out.println( randomNumber ); }}

Protokoll

0.4183351679424453
0.4183351679424453

Man kann den Ausdruck bewegen oder mehrere Vorkommen zu einem Vorkommen vereinigen, wenn der Ausdruck deterministisch ist (also jedes Auswertung denselben Wert ergibt) und die Auswertung des Ausdrucks keine Wirkungen hat. (Oder, wenn die Veränderungen bei Werten und Wirkungen in dem gegebenen Fall akzeptabel sind.)

Mathematische Funktionen (deterministische parametrisierte Methoden, wie »java.lang.Math.floor«) lassen sich also manchmal besser „optimieren“ als nicht-deterministische Methoden (wie »java.lang.Math.random«). Dies zeigt, daß es vorteilhaft sein kann, mathematische Funktionen erkennen und verwenden zu können.

Verkürzung von Quelltext

Der folgende Quelltext enthält zwei Wiederholungen der Ausgabe des Kehrreims.

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  {
    { java.lang.System.out.println( "Auf einem Baum ein Kuckuck, -" );
      { java.lang.System.out.println( "Sim sa la dim, bam ba," );
        java.lang.System.out.println( "Sa la du, sa la dim -" ); }
      java.lang.System.out.println( "Auf einem Baum ein Kuckuck sass." ); }
    { java.lang.System.out.println( "Da kam ein junger Jaeger, -" );
      { java.lang.System.out.println( "Sim sa la dim, bam ba," );
        java.lang.System.out.println( "Sa la du, sa la dim -" ); }
      java.lang.System.out.println( "Da kam ein junger Jaegersmann."    ); }
    { java.lang.System.out.println( "Der schoss den armen Kuckuck, -" );
      { java.lang.System.out.println( "Sim sa la dim, bam ba," );
        java.lang.System.out.println( "Sa la du, sa la dim -" ); }
      java.lang.System.out.println( "Der schoss den armen Kuckuck tot." ); }}}

Protokoll

Auf einem Baum ein Kuckuck, -
Sim sa la dim, bam ba,
Sa la du, sa la dim -
Auf einem Baum ein Kuckuck sass.
Da kam ein junger Jaeger, -
Sim sa la dim, bam ba,
Sa la du, sa la dim -
Da kam ein junger Jaegersmann.
Der schoss den armen Kuckuck, -
Sim sa la dim, bam ba,
Sa la du, sa la dim -
Der schoss den armen Kuckuck tot.

Wir können nun zunächst die Ausgabe des Kehrreims so umschreiben, daß diese nur noch ein java.lang.String-Literal enthält.

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  {
    { java.lang.System.out.println( "Auf einem Baum ein Kuckuck, -" );
      java.lang.System.out.println( "Sim sa la dim, bam ba," );
      java.lang.System.out.println( "Sa la du, sa la dim -" );
      java.lang.System.out.println( "Auf einem Baum ein Kuckuck sass." ); }
    { java.lang.System.out.println( "Da kam ein junger Jaeger, -" );
      java.lang.System.out.println( "Sim sa la dim, bam ba," );
      java.lang.System.out.println( "Sa la du, sa la dim -" );
      java.lang.System.out.println( "Da kam ein junger Jaegersmann."    ); }
    { java.lang.System.out.println( "Der schoss den armen Kuckuck, -" );
      java.lang.System.out.println( "Sim sa la dim, bam ba," );
      java.lang.System.out.println( "Sa la du, sa la dim -" );
      java.lang.System.out.println( "Der schoss den armen Kuckuck tot." ); }}}

Protokoll

Auf einem Baum ein Kuckuck, -
Sim sa la dim, bam ba,
Sa la du, sa la dim -
Auf einem Baum ein Kuckuck sass.
Da kam ein junger Jaeger, -
Sim sa la dim, bam ba,
Sa la du, sa la dim -
Da kam ein junger Jaegersmann.
Der schoss den armen Kuckuck, -
Sim sa la dim, bam ba,
Sa la du, sa la dim -
Der schoss den armen Kuckuck tot.

Alsdann können wir den Text des Kehrreims einmal als eine final-Variable definieren, so daß er im Quelltext nicht mehr wiederholt werden muß. Dadurch wird das Programm kürzer und übersichtlicher.

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { final java.lang.String kehrreim = "Sim sa la dim, bam ba," +
    java.lang.System.lineSeparator() + "Sa la du, sa la dim -";
    { java.lang.System.out.println( "Auf einem Baum ein Kuckuck, -" );
      java.lang.System.out.println( kehrreim );
      java.lang.System.out.println( "Auf einem Baum ein Kuckuck sass." ); }
    { java.lang.System.out.println( "Da kam ein junger Jaeger, -" );
      java.lang.System.out.println( kehrreim );
      java.lang.System.out.println( "Da kam ein junger Jaegersmann."    ); }
    { java.lang.System.out.println( "Der schoss den armen Kuckuck, -" );
      java.lang.System.out.println( kehrreim );
      java.lang.System.out.println( "Der schoss den armen Kuckuck tot." ); }}}

Protokoll

Auf einem Baum ein Kuckuck, -
Sim sa la dim, bam ba,
Sa la du, sa la dim -
Auf einem Baum ein Kuckuck sass.
Da kam ein junger Jaeger, -
Sim sa la dim, bam ba,
Sa la du, sa la dim -
Da kam ein junger Jaegersmann.
Der schoss den armen Kuckuck, -
Sim sa la dim, bam ba,
Sa la du, sa la dim -
Der schoss den armen Kuckuck tot.

Vereinfachung komplizierter Ausdrücke

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  {
    final int quotient =( 8 + 2 )/( 3 + 2 );
    java.lang.System.out.println( quotient ); }}

Protokoll

Durch Einführung von final-Variablen kann man den komplizierten Bruch in einen einfachen Bruch umwandeln und auf die runden Klammern verzichten.

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  {
    final int zaehler  = 8 + 2;
    final int nenner   = 3 + 2;
    final int quotient = zaehler / nenner;
    java.lang.System.out.println( quotient ); }}

Protokoll

Ein komplizierter Ausdruck kann viele Operatoren enthalten. Durch Zerlegung in mehrere kleinere Ausdrücke kann das Verständnis erleichtert werden.

Man sieht auch, wie die Kenntnis des Fachvokabulars („Zähler“, „Nenner“, „Quotient“) dabei hilft, gut Namen für die final-Variablen zu finden,

Beschriftung von Argumenten beim Aufruf von Methoden

Beim Aufruf der Methode »java.lang.Integer.toString(int,int)« wird die Bedeutung der Argumente nicht klar.

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { java.lang.System.out.println( "Anfang" );
    java.lang.System.out.println( java.lang.Integer.toString( 10, 10 ));
    java.lang.System.out.println( "Ende" ); }}

Protokoll

Anfang
10
Ende

Durch Konstanten können die Argumente auf erklärende Weise etikettiert werden.

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { java.lang.System.out.println( "Anfang" );
    { final int zahl = 10; 
      final int basis = 10;
      java.lang.System.out.println
      ( java.lang.Integer.toString( zahl, basis )); }
    java.lang.System.out.println( "Ende" ); }}

Protokoll

Anfang
10
Ende

Man beachte die Einhaltung der Stilregeln, denenzufolgen der Gültigkeitsbereich eines Namens möglichst klein sein sollte und unveränderliche Variablen bevorzugt werden sollten.

Genauere Fehlermeldungen

Wenn ein Fehler in der folgenden Zeile gemeldet wird, ist es nicht unbedingt immer einfach zu erkennen, ob der Aufruf von »f« oder der von »g« schuldig ist.

Quelltext

f( g() )

Im folgenden Quelltext hat jeder Aufruf seine eigenen Zeile. Fehlermeldungen, die eine bestimmte Zeile angeben, beziehen sich nun deutlich entweder auf »f« oder auf »g«.

Quelltext

var x = g();
f(x )

Semantische Differenzierung von Werten ⃗

Im Hawaiischen bedeutet „Aloha!“ sowohl „Guten Tag!“ als auch „Auf Wiedersehen!“. In dem folgenden Programm ist es nicht ganz sicher, was damit jeweils gemeint ist, man kann es aber erraten.

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { java.lang.System.out.println( "Aloha" + " Hans!" );
    java.lang.System.out.println( "Aloha" + " Lotte!" );
    java.lang.System.out.println
    ( "Das Ergebnis lautet: " + java.lang.Math.random() + "." );
    java.lang.System.out.println( "Aloha" + " Hans!" );
    java.lang.System.out.println( "Aloha" + " Lotte!" ); }}

Protokoll

Aloha Hans!
Aloha Lotte!
Das Ergebnis lautet: 0.9363307434242429.
Aloha Hans!
Aloha Lotte!

Hawaiianische Aussprache

Aloha əˈlohə

Schwierig werde könnte es, wenn „Aloha!“ einmal übersetzt werden soll, da dann in jedem einzelnen Fall zu entscheiden ist, ob es nun mit „Guten Tag!“ oder mit „Auf Wiedersehen!“ zu übersetzen ist.

Durch final-Variablen können die beiden Bedeutungen von Anfang an semantisch differenziert werden.

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { final java.lang.String begruessung = "Aloha";
    final java.lang.String verabschiedung = "Aloha";
    java.lang.System.out.println( begruessung + " Hans!" );
    java.lang.System.out.println( begruessung + " Lotte!" );
    java.lang.System.out.println
    ( "Das Ergebnis lautet: " + java.lang.Math.random() + "." );
    java.lang.System.out.println( verabschiedung + " Hans!" );
    java.lang.System.out.println( verabschiedung + " Lotte!" ); }}

Protokoll

Aloha Hans!
Aloha Lotte!
Das Ergebnis lautet: 0.8393148633922421.
Aloha Hans!
Aloha Lotte!

`final`-Variablen als Ersatz für Einheiten ⃗

Durch final-Variablen können Einheiten im Quelltext ausgedrückt werden. Allerdings prüft die Java -Implementation dabei nicht die Einhaltung der Rechenregeln für Einheiten (Dimensionen).

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { final double meter = 1;
    final double zentimeter = 0.01;
    java.lang.System.out.println
    ( "Das Ergebnis lautet " +
      ( 4 * meter + 3 * zentimeter )+ 
      " Meter."  ); }}

Protokoll

Das Ergebnis lautet 4.03 Meter.

Rettung und Wiederherstellung einer Information ⃗

Durch final-Variablen können Zustände von Systemen vor einer Änderung gesichert (oder „gerettet“, das heißt: gespeichert) werden und später wiederhergestellt werden.

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  {
    final java.lang.String name = "file.separator";
    final java.lang.String orig = java.lang.System.getProperty( name ); /* retten */
    java.lang.System.setProperty( name, "abc" );   /* verändern */
    java.lang.System.setProperty( name, orig );    /* wiederherstellen */ }}

Protokoll

(keine Ausgabe)

Muß man `final`-Variablen vor der Verwendung deklarieren? ⃗

Manchmal wird behauptet, daß Deklarationen Programmierer zwingen, ihre Programm vorherzuplanen, weil sie erst Deklarationen schreiben müssen, bevor sie Namen verwenden. Dies stimmt aber nicht. Hier wird die Reihenfolgen im Quelltext mit der Reihenfolge der Schreibzeit verwechselt. Natürlich steht es einem Programmierer frei, zuerst die Verwendung einer final-Variablen ohne deren Deklaration zu schreiben.

Main.txt

public final class Main
{ public static void main( final java.lang.String[] args )
  {
    java.lang.System.out.println( 2 * pi ); }}

Danach kann der Programmierer dann mit der Schreibmarke nach oben gehen und dort die Deklaration einfügen.

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  {
    final double pi = 3.1415926535897932384626433832795;
    java.lang.System.out.println( 2 * pi ); }}

Protokoll

6.283185307179586

Falls jemand sich durch die „Pflicht zum Deklarieren“ von final-Variablen beim Schreiben abgelenkt fühlt, kann er das ganze Program zunächst erst einmal ohne die Deklarationen schreiben und sich auf die eigentlichen Werte und Rechnungen konzentrieren.

Main.text

public final class Main
{ public static void main( final java.lang.String[] args )
  { netto  = 120;
    brutto = netto * 1.11;
    println( brutto ); }}

Solch ein Entwurf kann nun natürlich noch nicht compiliert und ausgeführt werden; irgendwann müssen die Deklarationen dann doch noch hinzugefügt werden. Dabei ist dann der richtige Datentyp für jeden Namen zu wählen.

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { final double netto  = 120;
    final double brutto = netto * 1.11;
    java.lang.System.out.println( brutto ); }}

Protokoll

133.20000000000002

Dann kann schließlich noch der „Schönheitsfehler“ der vielen Nachkommastellen angegangen werden.

Lesbarkeit ⃗

Welche der folgenden vier großen Numeralia sind einander gleich und welche unterschiedlich?

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { 
    java.lang.System.out.println
    ( 9_007_199_254_740_991. + 1. - 9_007_199_254_740_991. - 1. );

    java.lang.System.out.println
    ( 9_007_199_254_740_992. + 1. - 9_007_199_254_740_992. - 1. ); 
    }}

Protokoll

0.0
-1.0

Es ist einfacher zu erkennen, wann zwei Buchstaben einander gleich sind! Außerdem drückt »b = a + 1« die Beziehung zwischen den beiden großen Zahlen direkt aus.

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { final double a = 9_007_199_254_740_991.;
    final double b = a + 1.;
    java.lang.System.out.println( a + 1. - a - 1. );
    java.lang.System.out.println( b + 1. - b - 1. ); }}

Protokoll

0.0
-1.0

Produkte und Quotienten ⃗

In der Mathematik ist es auch üblich, für das Produkt zweier Werte ‹a› und ‹b› zu schreiben: ‹ab›, ‹a·b›, oder ‹a×b›. In Java muß das Produkt ‹ab›, ‹a·b›, oder ‹a×b› aber immer als »a*b« geschrieben werden.

Für das Fünffache eines Wertes ‹ x › schreibt man in der Mathematik oft ‹ 5x ›. In Java muß für Produkte stets der Multiplikationsoperator »*« verwendet, also »5 * x«.

Die Schreibweise ‹a/bc› oder ‹a/b·c› soll in der Mathematik oder im Alltag manchmal ‹a/(b·c)› bedeuten, in Java bedeutet der Ausdruck »a/b*c« aber immer »(a/b)*c«. Man darf die Schreibweise »a/b*c« in Java also niemals als »a/(b*c)« interpretieren!

Genauso soll die Schreibweise ‹a·b/c·d› soll in der Mathematik oder im Alltag manchmal ‹(a·b)/(c·d)› bedeuten, in Java bedeutet der Ausdruck »a*b/c*d« aber immer »((a*b)/c)*d«. Man darf die Schreibweise »a*b/c*d« in Java also niemals als »(a*b)/(c*d)« interpretieren!

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  {
    final int a   = 8;
    final int b   = 4;
    final int ab  = 1;
    final int axb = 3;
    final int c   = 2;
    java.lang.System.out.println( ab      );
    java.lang.System.out.println( axb     );
    java.lang.System.out.println( a*b     );
    java.lang.System.out.println( a/b*c   );
    java.lang.System.out.println( a/(b*c) ); }}

Protokoll

`final`-Variablen für prominente mathematische Konstanten ⃗

In manchen Programmiersprachen gibt es keine vordefinierten Namen für die mathematischen Konstanten ‹ π › (pi) und ‹ e ›. Dann kann man sich diese leicht mit Hilfe von mathematischen Funktionen definieren, wie folgendes Beispiel zeigt.

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  {
    final double pi = 4 * java.lang.Math.atan2( 1, 1 );
    final double p1 = 4 * java.lang.Math.atan( 1 );
    final double e  = java.lang.Math.exp( 1 );
    java.lang.System.out.println( pi );
    java.lang.System.out.println( p1 );
    java.lang.System.out.println( e  ); }}

transcript

3.141592653589793
3.141592653589793
2.718281828459045

Werte und Wirkungen ⃗

Oft sind Methoden, die einen Wert liefern, nützlicher als Methoden, die eine Wirkung haben. Ein Wert kann in einer final-Variablen zwischengespeichert werden. Dann kann entschieden werden, was mit ihm gemacht wird – beispielsweise, ob er weiterverarbeitet oder ausgegeben wird.

Das folgende Programm zeigt eine fest programmierte Ausgabe.

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  {
    java.lang.System.out.println( java.lang.Math.cos( 0 ) ); }}

Protokoll

1.0

Das folgende Programm zeigt, wie das Ergebnis einer Berechnung zunächst in einer Variablen gespeichert werden kann.

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  {
    final double y = java.lang.Math.cos( 0 );
    java.lang.System.out.print( y ); }}

Protokoll

1.0

In dem obigen Programmbeispiel ist die Speicherung des Ergebnisses in einer Variablen aber nicht wirklich von Vorteil. Das Programm illustriert nur das Prinzip.

Beispiele für Berechnungen ⃗

Kelvin/Celsius-Umwandlung ⃗

Das folgende Programm errechnet aus einem benannten Wert »2«, der eine Temperatur in Kelvin darstellen soll, einen anderen benannten Wert: die entsprechende Celsius-Temperatur.

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { final double kelvintemperatur  =    2;
    final double celsiusversatz    = -273.15;
    final double celsiustemperatur = kelvintemperatur + celsiusversatz;
    final java.lang.String ausgabe = 
    "Temperatur = " + kelvintemperatur + " Kelvin";
    final java.lang.String ausgabe1 = 
    "Temperatur = " + celsiustemperatur + " Grad Celsius";
    java.lang.System.out.println( ausgabe );
    java.lang.System.out.println( ausgabe1 ); }}

transcript

Temperatur = 2.0 Kelvin
Temperatur = -271.15 Grad Celsius

Man sieht in diesem Programm auch, daß zur Initialisierung (rechts vom Gleichheitszeichen) ein beliebig komplexer Wertausdruck, wie beispielsweise »temperatur + celsiusversatz«, verwendet werden kann, der Initialisierungsausdruck muß nicht immer ein einfaches Literal sein.

Man sieht in diesem Programm außerdem auch einmal ein Beispiel für eine final-Variablen vom Typ »java.lang.String«, welche den auszugebenden Text enthält, der als Verkettung von Texten und einem Zahlenwert aufgebaut wird.

Ausdrücke, die neben Operatoren nur Konstanten und Literale enthalten, können oft bereits während der Übersetzung eines Programms ausgewertet werden, ihre Auswertung kostet daher oft nur wenig Laufzeit.

Umwandlung von 2 Zoll in Zentimeter ⃗

Während sich im Alltag die Verwendung von Einheiten bewährt hat, kann man in Java -Programmen Einheiten nicht direkt verwenden. Das folgende Programm zeigt einen Notbehelf, der es erlaubt, eine Einheit wenigstens anzudeuten. Man kann für „2,54 Zentimeter“ im Quelltext »2.54 * zentimeter« schreiben, wenn »zentimeter« zuvor entsprechend, nämlich mit dem Wert »1«, deklariert wurde. »2.54 * zentimeter« hat dann den Wert von »2.54« drückt aber aus, daß es sich um Zentimeter handeln soll.

Diese Vorgehensweise basiert darauf, daß für dieses Programm der Zentimeter als Basiseinheit festgelegt wurde; und „1 Zentimeter“ ausgedrückt in der Basiseinheit „Zentimeter“ hat dann eben den Zahlenwert 1. Nach der entsprechenden Deklaration des Zentimeters kann dann der Zoll als „2,54 Zentimeter“ deklariert werden. Schließlich werden zwei Längen deklariert, wobei nun beide Einheiten verwendet werden können. Aufgrund der Wahl des Zentimeters als Basiseinheit für das Programm erfolgt die Ausgabe aller Längen dann in Zentimeter, wenn sie nicht weiter umgerechnet werden. Entsprechend wird die zuvor als „2 Zoll“ deklarierte Variable »laenge« dann in Zentimeter ausgegeben, wodurch also die Länge von 2 Zoll in Zentimeter dargestellt wird.

(Das Programm vermeidet die Ausgabe von Umlauten. Diese ist zwar mit Java grundsätzlich möglich, aber die Zeichensätze des verwendeten Editors und der verwendeten Java -Implementation sowie der Zeichensatz und Schriftschnitt der zur Ausgabe verwendeten Konsole müssen dazu manchmal erst richtig eingestellt werden.)

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { final double zentimeter  = 1;
    final double zoll        = 2.54 * zentimeter;
    final double laenge      = 2    * zoll;
    java.lang.System.out.println( "Laenge   = " + laenge  + " cm" ); }}

transcript

Laenge   = 5.08 cm

Berechnung der Mehrwertsteuer zu 70 Euro Warenwert (Nettowert) ⃗

Das folgende Beispiel geht davon aus, daß die Mehrwertsteuer in dem hypothetischen Land, in dem das Programm benutzt werden soll, 19 Prozent beträgt. Es verwendet die Währung Euro als interne Basiseinheit, weswegen in diesem Programm ein Euro den Zahlenwert 1 hat und entsprechend deklariert wird.

Java hat keine

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { final double mehrwertsteuersatz =  0.19;
    final double euro               =  1;
    final double warenwert          = 70 * euro;
    final double mwst =
    mehrwertsteuersatz * warenwert;
    final java.lang.String warenwertAusgabe =
    "Warenwert      = " + warenwert + " Euro";
    final java.lang.String mwstAusgabe =
    "Mehrwertsteuer = " + mwst + " Euro";
    java.lang.System.out.println( warenwertAusgabe );
    java.lang.System.out.println( mwstAusgabe      ); }}

transcript

Warenwert      = 70.0 Euro
Mehrwertsteuer = 13.3 Euro

Berechnung der Fläche eines Kreises mit Radius 3 Meter ⃗

Das folgende Programm zeigt die Berechnung der Fläche eines Kreises. Es verwendet intern die Länge von einem Meter als Basiseinheit für Längen.

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { final double pi      = java.lang.Math.PI;
    final double meter   = 1;
    final double r       = 3 * meter;
    final double flaeche = pi * java.lang.Math.pow( r, 2 );
    java.lang.System.out.println
    ( "*** Kreisberechnung ***" ); 
    java.lang.System.out.println
    ( "Radius  = " + r + " Meter" ); 
    java.lang.System.out.println
    ( "Flaeche = " + flaeche + " Quadratmeter" ); }}

transcript

*** Kreisberechnung ***
Radius  = 3.0 Meter
Flaeche = 28.274333882308138 Quadratmeter

Anwendungsmöglichkeiten lokaler final-Variablen in Java

Laufzeit-final-Variablen

Bezüge auf die Zukunft

Auflösung von Verschachtelungen

Verteilung einer Information an mehrere Stellen

Vermeidung unnötiger doppelter Berechnungen

Verkürzung von Quelltext

Vereinfachung komplizierter Ausdrücke

Beschriftung von Argumenten beim Aufruf von Methoden

Genauere Fehlermeldungen

Semantische Differenzierung von Werten ⃗

final-Variablen als Ersatz für Einheiten ⃗

Rettung und Wiederherstellung einer Information ⃗

Muß man final-Variablen vor der Verwendung deklarieren? ⃗

Lesbarkeit ⃗

Produkte und Quotienten ⃗

final-Variablen für prominente mathematische Konstanten ⃗

Werte und Wirkungen ⃗

Beispiele für Berechnungen ⃗

Kelvin/Celsius-Umwandlung ⃗

Umwandlung von 2 Zoll in Zentimeter ⃗

Berechnung der Mehrwertsteuer zu 70 Euro Warenwert (Nettowert) ⃗

Berechnung der Fläche eines Kreises mit Radius 3 Meter ⃗

Anwendungsmöglichkeiten lokaler `final`-Variablen in Java

Laufzeit-`final`-Variablen

`final`-Variablen als Ersatz für Einheiten ⃗

Muß man `final`-Variablen vor der Verwendung deklarieren? ⃗

`final`-Variablen für prominente mathematische Konstanten ⃗