Numerische Operatoren in Java

Hallo! Heute betrachten wir ein sehr wichtiges Thema, nämlich numerische Operatoren in Java . Beim Programmieren gibt es überall Zahlen. Wenn Sie tiefer graben und sich an die High School erinnern, erinnern Sie sich vielleicht daran, dass ein Computer alle Informationen in einem numerischen Format darstellt: Kombinationen aus Nullen und Einsen, auch als Binärcode bekannt. Es gibt viele numerische Operatoren in der Programmierung, daher werden wir anhand von Beispielen die wichtigsten davon untersuchen :) Beginnen wir mit dem einfachsten: arithmetischen Operatoren . Dies sind die bekannten Additions- ( +), Subtraktions- ( -), Multiplikations- ( *) und Divisionsoperatoren ( /).

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = 33;

       System.out.println(x+y);
       System.out.println(x-y);
       System.out.println(x*y);
       System.out.println(x/y);
   }
}

Konsolenausgabe: 1032 966 32967 30 Das alles haben Sie bereits verwendet. Zu dieser Gruppe können Sie den Rest- oder Modulo-Operator ( ) hinzufügen %.

public class Main {

   public static void main(String[] args) {

       int x = 33;
       int y = 33%2;
       System.out.println(y);
   }
}

Konsolenausgabe: 1 In diesem Beispiel dividieren wir 33 durch 2. Dies ergibt 16, mit einem zusätzlichen „Ende“ (eins), das nicht durch 2 teilbar ist. Dieses „Ende“ ist das Ergebnis der Operation „Rest aus der Division“. Java implementiert auch Vergleichs-/Relationsoperatoren (genau wie in der Mathematik). Sie kennen sie bestimmt auch aus der Schule:

• gleich ( ==)
• größer als ( >)
• weniger als ( <)
• größer oder gleich ( >=)
• kleiner oder gleich ( <=)
• ungleich ( !=)

Hier sollten Sie auf einen wichtigen Punkt achten, der bei vielen Anfängern zu Fehlern führt. Der „equals“-Operator wird geschrieben ==, nicht =. In Java ist ein Single =der Zuweisungsoperator , der verwendet wird, wenn einer Variablen eine Zahl, eine Zeichenfolge oder der Wert einer anderen Variablen zugewiesen wird .

public class Main {

   public static void main(String[] args) {

       int x = 33;
       int y = 999;
       System.out.println(x=y);// We expect false to be displayed
   }
}

Konsolenausgabe: 999 Ups! Dies ist offensichtlich nicht das Ergebnis, das wir erwartet hatten. Es ist ein völlig anderer Datentyp: Wir haben erwartet, einen booleschen Wert zu sehen , aber wir haben eine Zahl erhalten. Alles nur, weil wir in den Klammern einen Zuweisungsoperator anstelle eines Vergleichs verwendet haben . x=y Der Wert y(999) wurde der Variablen zugewiesen x, und dann haben wir den Wert von angezeigt x. So geht's richtig:

public class Main {

   public static void main(String[] args) {

       int x = 33;
       int y = 999;
       System.out.println(x==y);
   }
}

Konsolenausgabe: false Jetzt haben wir die beiden Zahlen richtig verglichen! :) Hier ist eine weitere Funktion des Zuweisungsoperators ( =): Er kann miteinander „verkettet“ werden:

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = 33;
       int z = 256;

       x = y = z;
       System.out.println(x);
   }
}

Konsolenausgabe: 256 Denken Sie daran, dass die Zuweisung von rechts nach links erfolgt . Dieser Ausdruck ( x = y = z) wird in Schritten ausgeführt:

• y = z, das ist,y = 256
• x = y, das ist,x = 256

Unäre Operatoren.

Sie werden „ unär “ genannt , abgeleitet vom Wort „ uno “, was „ eins “ bedeutet . Sie haben diesen Namen erhalten, weil sie im Gegensatz zu den vorherigen Operatoren auf eine einzige Nummer reagieren und nicht auf mehrere. Diese beinhalten:

• Unäres Minus. Es dreht das Vorzeichen der Zahl um.

public class Main {

   public static void main(String[] args) {

       int x = 999;

       // Change the sign for the first time
       x = -x;
       System.out.println(x);

       // Change the sign for the second time
       x= -x;
       System.out.println(x);
   }
}

Konsolenausgabe: -999 999 Wir haben den unären Minusoperator zweimal verwendet. Dadurch war unsere Zahl zunächst negativ und wurde dann wieder positiv!

• Inkrementieren (++) und Dekrementieren (--)

Der ++Operator erhöht eine Zahl um eins und der --Operator verringert eine Zahl um den gleichen Betrag.

public class Main {

   public static void main(String[] args) {

       int x = 999;
       x++;
       System.out.println(x);

       x--;
       System.out.println(x);
   }
}

Konsolenausgabe: 1000 999 Diese Notation kommt Ihnen vielleicht bekannt vor, wenn Sie schon einmal von der Sprache C++ gehört haben. Seine Erfinder verwendeten diesen interessanten Namen, um die Idee zu vermitteln, dass „C++ eine Erweiterung der C-Sprache ist“. Eine beliebte verbesserte Version von Notepad heißt Notepad++. Hier ist ein wichtiger Punkt. Es gibt zwei Arten von Inkrementierungs- und Dekrementierungsoperatoren: Postfix und Präfix . x++- Postfix ++x- Präfix Was ist der grundlegende Unterschied zwischen der Angabe der Plus-/Minuszeichen vor oder nach der Zahl? Wir werden im folgenden Beispiel sehen:

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = x++;
       System.out.println(y);
   }
}

Konsolenausgabe: 999 Etwas stimmt nicht! Wir wollten um 1 erhöhen xund den neuen Wert der Variablen y zuweisen. Mit anderen Worten, y sollte 1000 sein. Aber stattdessen erhalten wir etwas anderes: 999. Es scheint, als ob x nicht erhöht wurde und dass der Inkrementoperator nicht funktioniert hat? Aber es hat funktioniert. Um sich selbst zu überzeugen, versuchen Sie es xam Ende anzuzeigen :)

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = x++;
       System.out.println(y);
       System.out.println(x);
   }
}

Konsolenausgabe: 999 1000 Genau aus diesem Grund wird diese Operation als Postfix bezeichnet: Sie wird nach dem Hauptausdruck ausgeführt. Das bedeutet in unserem Fall: int y = x++; y = xwird zuerst ausgeführt (und die Variable ywird auf den Wert von initialisiert x) und erst dann x++ausgeführt. Was ist, wenn dies nicht das gewünschte Verhalten ist? Dann müssen wir die Präfixnotation verwenden :

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = ++x;
       System.out.println(y);
   }
}

In diesem Fall ++xwird zuerst verarbeitet und erst danach y = x; hingerichtet. Sie sollten sich diesen Unterschied sofort merken, um Fehler in einem echten Programm zu vermeiden, bei dem die Verwendung von Postfix anstelle von Präfix alles auf den Kopf stellen könnte :)

Zusammengesetzte Operatoren

Darüber hinaus gibt es in Java sogenannte zusammengesetzte Operatoren. Sie kombinieren zwei Operatoren:

• Abtretung
• Rechenzeichen

Diese beinhalten:

• +=
• -=
• *=
• /=
• %=

Betrachten wir ein Beispiel:

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = 33;

       x += y;
       System.out.println(x);
   }
}

Konsolenausgabe: 1032 x += y bedeutet x = x + y. Der Kürze halber werden die beiden Symbole nacheinander verwendet. Die Kombinationen -=, *=und funktionieren auf ähnliche Weise /=.%=

Logische Operatoren

Neben numerischen Operatoren gibt es in Java auch Operationen, die boolesche Werte ( true und false ) beinhalten. Diese Operationen werden mithilfe logischer Operatoren ausgeführt

• !- logisches NICHT . Es dreht den Wert eines booleschen Werts um

public class Main {

   public static void main(String[] args) {

       boolean x = true;
       System.out.println(!x);
   }
}

Konsolenausgabe: false

• &&- logisches UND . Es gibt nur dann true zurück, wenn beide Operanden true sind.

public class Main {

   public static void main(String[] args) {

       System.out.println(100 > 10 && 100 > 200);
       System.out.println(100 > 50 && 100 >= 100);
   }
}

Konsolenausgabe: false true Das Ergebnis der ersten Operation ist falsch, da einer der Operanden falsch ist, nämlich 100 > 200. Um „true“ zurückzugeben, &&erfordert der Operator, dass beide Operanden „true“ sind (wie es in der zweiten Zeile der Fall ist).

• ||- logisches ODER . Es gibt true zurück, wenn mindestens einer der Operanden true ist.

Wenn wir diesen Operator verwenden, liefert unser vorheriges Beispiel ein anderes Ergebnis:

public class Main {

   public static void main(String[] args) {

       System.out.println(100 > 10 || 100 > 200);
   }
}

Konsolenausgabe: true Der Ausdruck 100 > 200ist immer noch falsch, aber für den OR- Operator reicht es völlig aus, dass der erste Teil ( 100 > 10) wahr ist.