Vergleichsverbunde in Java 

Einführung

Ein Vergleichsverbund ist ein Operator, der eine Oder-Verbindung zweier Vergleiche darstellt.

Der Vergleichsverbund »<=« ist so definiert, daß die Inkarnation »x <=y « für zwei Werte »x « und »y « genau dann wahr ist, wenn »x « kleiner als »y « oder  »x « gleich »y « ist.

Der Ausdruck »1 <= 2« hat daher beispielsweise den Wert »true« (»1« ist kleiner  als »2«, auch wenn »1« nicht gleich  »2« ist).

Main.java

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

Protokoll

true

Entsprechend ist die Inkarnation» x >=y « für zwei Werte »x « und »y « genau dann wahr ist, wenn »x « größer als »y « oder  »x « gleich »y « ist.

Der Ausdruck »2 >= 2« hat daher beispielsweise den Wert »true« (»2« ist zwar nicht größer  als »2«, aber gleich  »2«).

Main.java

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

Protokoll

true

Morphologie

Bei den Operatoren »<=« und »>=« handelt es sich jeweils um eine lexikalische Einheit mit zwei Zeichen. Die Reihenfolge der beiden Zeichen darf darin nicht vertauscht werden, und es darf kein Leerraum zwischen die beiden Zeichen eingefügt werden.

(Andere Operatoren mit mehreren Zeichen sind »==« und »!=«.)

Syntax

In dem folgenden Syntaxdiagramm ist ein »Additiver Ausdruck« ein eingeklammerter Ausdruck, oder ein Ausdruck, dessen Hauptoperator ein Vorzeichen oder eine Grundrechenart ist.

Syntaxdiagramm

Beziehungsausdruck
        .--------------------.         
---.--->| Additiver Ausdruck |---------------------------------------.--->
   |    '--------------------'                                       |
   |    .--------------------.     .-.      .--------------------.   |
   '--->| Beziehungsausdruck |--->( < )---->| Additiver Ausdruck |---'
   |    '--------------------'     '-'      '--------------------'   |
   |    .--------------------.     .-.      .--------------------.   |
   '--->| Beziehungsausdruck |--->( > )---->| Additiver Ausdruck |---'
   |    '--------------------'     '-'      '--------------------'   |
   |    .--------------------.     .--.     .--------------------.   |
   '--->| Beziehungsausdruck |--->( <= )--->| Additiver Ausdruck |---'
   |    '--------------------'     '--'     '--------------------'   |
   |    .--------------------.     .--.     .--------------------.   |
   '--->| Beziehungsausdruck |--->( >= )--->| Additiver Ausdruck |---'
        '--------------------'     '--'     '--------------------'

Syntax eines Ausdrucks ⊚

Die Syntax eines Zuweisungsausdrucks  wird nun so angepaßt, daß sie auch Beziehungsausdrücke berücksichtigt.

Syntaxdiagramm

Zuweisungsausdruck
        .--------------------.         
---.--->| Beziehungsausdruck |---------------------.--->
   |    '--------------------'                     |
   |    .------------.     .-.      .----------.   |
   '--->| Bezeichner |--->( = )---->| Ausdruck |---'
        '------------'     '-'      '----------'

Bezeichnungen der Operanden

Die Operanden der hier vorgestellten Operatoren werden als Komparanden  („linker Komparand“, „rechter Komparand“) bezeichnet.

Mathematische Schreibweise

Ähnliche Operatoren in der Schulmathematik sind ‹≤› beziehungsweise ‹≥›.

Die mathematische Schreibweise stellt eine Art von vertikaler  Kombination eines Kleiner-Zeichens mit einem Gleich-Zeichen dar, während die Java -Schreibweise eine horizontale  Kombination dieser beiden Zeichen ist.

Aussprache

Der Operator »<=« wird meist „kleiner-gleich“ gesprochen.

Der Operator »>=« wird meist „größer-gleich“ gesprochen.

Priorität

Die Priorität und Assoziativitätsrichtung der Vergleichsoperatoren »<=« und »>=« sind wie bei den schon behandelten Vergleichen »<« und »>«.

Die folgende Tabelle gibt die Assoziativitätsrichtung und die Priorität der bisher behandelten Operatoren wieder.

Eigenschaften

              S P A    (S = Stelligkeit ("Aritaet"), P = Position, A = Assoziativitaet)
()            1 Z      Eingeklammerter Ausdruck
+  -          1 P      Unaere vorangestellte Operatoren (Vorzeichen)
*  /          2 I L    "Punktrechnung":  Multiplikation, Division
+  -          2 I L    "Strichrechnung": Addition, Subtraktion
<  >  <=  >=  2 I L    Vergleiche
== !=         2 I L    Gleichheitspruefung und Ungleichheitspruefung
=             2 I R    Zuweisung

Typanforderungen (vereinfacht)

Die Typanforderungen der Vergleichsoperatoren »<=« und »>=« sind wie bei den schon behandelten Vergleichen »<« und »>«.

Typregeln

Die Typregeln der Vergleichsoperatoren »<=« und »>=« sind wie bei den schon behandelten Vergleichen »<« und »>«.

Semantik (Wert)

Auswertung der Operanden

Bei der Auswertung der Operatoren »<=« und »>=« werden zunächst beide Komparanden (von links nach rechts) ausgewertet.

Main.java

public final class Main
{ 
  public static int print( final java.lang.String s )
  { java.lang.System.out.println( s ); return 0; }
  public static void eval( final boolean b ){}
  public static void main( final java.lang.String[] args )
  { eval( print( "abc" )<= print( "def" ));
    eval( print( "ghi" )<= print( "jkl" )); }}

Protokoll

abc
def
ghi
jkl

Ermittlung des Wertes

Der Wert eines Vergleiches mit »<=« ist »true« genau dann, wenn der Wert des linken Komparanden kleiner als der Wert des rechten Komparanden ist oder  wenn der Wert des linken Komparanden dem Wert des rechten Komparanden gleich ist.

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { 
    java.lang.System.out.println( 2 < 2 ); 
    java.lang.System.out.println( 2 == 2 ); 
    java.lang.System.out.println( 2 <= 2 );
    java.lang.System.out.println();
    java.lang.System.out.println( 2 < 3 ); 
    java.lang.System.out.println( 2 == 3 ); 
    java.lang.System.out.println( 2 <= 3 ); 
    java.lang.System.out.println();
    java.lang.System.out.println( 4 < 2 ); 
    java.lang.System.out.println( 4 == 2 ); 
    java.lang.System.out.println( 4 <= 2 ); }}

Protokoll

false
true
true

true
false
true

false
false
false

Der Wert eines Vergleiches mit »>=« ist »true« genau dann, wenn der Wert des linken Operanden größer als der Wert des rechten Operanden ist oder wenn der Wert des linken Operanden dem Wert des rechten Operanden gleich ist.

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { java.lang.System.out.println( 2 > 2 ); 
    java.lang.System.out.println( 2 == 2 ); 
    java.lang.System.out.println( 2 >= 2 );
    java.lang.System.out.println();
    java.lang.System.out.println( 2 > 3 ); 
    java.lang.System.out.println( 2 == 3 ); 
    java.lang.System.out.println( 2 >= 3 ); 
    java.lang.System.out.println();
    java.lang.System.out.println( 4 > 2 ); 
    java.lang.System.out.println( 4 == 2 ); 
    java.lang.System.out.println( 4 >= 2 ); }}

Protokoll

false
true
true

false
false
false

true
false
true

Die Inkarnation »x >=y « hat für zwei Werte »x « und »y « denselben Wert wie »y <=x «.

Vergleiche mit der Unzahl “not a number ” ergibt jedoch stets »false« (außer beim Operator »!=«).

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { 
    final double notANumber = 0.0 / 0.0;
    java.lang.System.out.println( 0 <= notANumber );
    java.lang.System.out.println( 0 > notANumber ); }}

Protokoll

false
false

Positive und Negative Zahlen

Zahlen ‹x› mit ‹x>0› sind positiv. Zahlen ‹x› mit ‹x≥0› sind nicht-negativ.

Zahlen ‹x› mit ‹x<0› sind negativ. Zahlen ‹x› mit ‹x≤0› sind nicht-positiv.

Die Zahl Null  ist also weder positiv noch negativ.

Übungsfragen

?   Übungsfrage

Welche Ausgabe erzeugt das folgende Programm?

Main.java

public final class Main
{ 
  public static boolean f( final int i ){ return i <= 4; }
  public static void main( final java.lang.String[] args )
  { java.lang.System.out.println( f( 4 ));
    java.lang.System.out.println( f( 5 )); }}

Übungsaufgaben

/   kleinergleich

Überarbeiten Sie die Deklaration des Prädikat »kleinergleich«, so daß der Operator »<=« nicht mehr darin vorkommt, aber das Prädikat dieselben Ergebnisse für dieselben Argumentwerte liefert.

Main.java

public final class Main
{
  public static boolean kleinergleich( final int i, final int j )
  { return i <= j; }
  public static void main( final java.lang.String[] args )
  { java.lang.System.out.println(  kleinergleich( 0,  1 ));
    java.lang.System.out.println(  kleinergleich( 0,  0 ));
    java.lang.System.out.println( !kleinergleich( 0, -1 )); }}

Protokoll

true
true
true

/   Positiv

Schreiben Sie eine Deklaration eines Prädikat »positiv« mit einem int-Parameter, so daß eine Inkarnation jenes Prädikats den Wert »true« genau dann hat, wenn der Wert des Arguments jener Inkarnation positiv  ist.

Main.java

public final class Main
{
  __________
  public static void main( final java.lang.String[] args )
  { java.lang.System.out.println( !positiv( -1 ));
    java.lang.System.out.println( !positiv(  0 ));
    java.lang.System.out.println(  positiv(  1 ));
    java.lang.System.out.println(  positiv(  2 )); }}

Protokoll

true
true
true
true

Unendlich und die Unzahl *

Unendlich gilt als größer als jeder andere double-Wert (außer die Unzahl “not a number ”) und minus Unendlich gilt als kleiner als jeder andere double-Wert (außer die Unzahl “not a number ”).

Vergleiche mit der Unzahl “not a number ” auf einer Seite ergeben stets »false«, außer beim Operator »!=«, für den sich mit “not a number ” auf einer Seite stets »true« ergibt.

Main.java

public final class Main
{ public static void main( final java.lang.String[] args )
  { 
    final double infinity = 1.0 / 0.0;
    final double notANumber = 0.0 / 0.0;
    final double maximum = 0x1.fffffffffffffp1023;
    java.lang.System.out.println(  notANumber == 1            ); /* false                  */
    java.lang.System.out.println(  notANumber != 1            ); /* true                   */
    java.lang.System.out.println(  notANumber == notANumber   ); /* false                  */
    java.lang.System.out.println(  notANumber != notANumber   ); /* true                   */
    java.lang.System.out.println(  notANumber <  notANumber   ); /* false                  */
    java.lang.System.out.println(  notANumber >= notANumber   ); /* false                  */
    java.lang.System.out.println(  infinity                   ); /* Infinity               */
    java.lang.System.out.println(  notANumber                 ); /* NaN                    */
    java.lang.System.out.println(  maximum                    ); /* 1.7976931348623157E308 */
    java.lang.System.out.println(  maximum    <  infinity     ); /* true                   */
    java.lang.System.out.println( -infinity   <  infinity     ); /* true                   */
  
    java.lang.System.out.println(  maximum    <  maximum + 1  ); /* false                  */
    java.lang.System.out.println(  infinity   <  infinity + 1 ); /* false                  */
    java.lang.System.out.println(  notANumber <  infinity     ); /* false                  */
    java.lang.System.out.println(  notANumber == infinity     ); /* false                  */
    java.lang.System.out.println(  infinity   == notANumber   ); /* false                  */
    java.lang.System.out.println(  infinity   <  notANumber   ); /* false                  */
    java.lang.System.out.println(  notANumber <  notANumber   ); /* false                  */
    }}

Protokoll

false
true
false
true
false
false
Infinity
NaN
1.7976931348623157E308
true
true
false
false
false
false
false
false
false

Das folgende Programm zeigt eine übliche Art der Erkennung der Unzahl “not a number ”.

Main.java

public final class Main
{
  public static boolean isNaN( final double value )
  { return value != value; }
  public static void main( final java.lang.String[] args )
  { 
    final double infinity = 1.0 / 0.0;
    final double notANumber = 0.0 / 0.0;
    java.lang.System.out.println( isNaN( notANumber ));
    java.lang.System.out.println( isNaN( 0.0 ));
    java.lang.System.out.println( isNaN( 1.0 ));
    java.lang.System.out.println( isNaN( infinity )); }}

Protokoll

true
false
false
false