JavaRush /Java-Blog /Random-DE /Zahlenoperationen in Java

Level 41

28 Februar 2021
45 views
0 comments

Zahlenoperationen in Java

Hallo! Heute werden wir uns mit einem sehr wichtigen Thema befassen, nämlich Zahlenoperationen in Java . Zahlen sind in der Programmierung allgegenwärtig. Wenn Sie sich mit dem Lehrplan befassen, werden Sie sich daran erinnern, dass alle Informationen auf einem Computer in einem numerischen Format – Kombinationen aus Nullen und Einsen – dargestellt werden, das auch Binärcode genannt wird. Zahlenoperationen in Java - 2

Es gibt sehr viele Operationen mit Zahlen in der Programmierung, daher werden wir uns die wichtigsten davon anhand von Beispielen ansehen :)

Rechenoperationen

Beginnen wir mit der einfachsten Sache – mit arithmetischen Operationen. Dies sind die bekannten Additionen (+), Subtraktion (-), Multiplikation (*) und Division (/).

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:

Das alles haben Sie bereits genutzt. Sie können ihnen eine Operation hinzufügen %– den Rest der Division.

public class Main {

   public static void main(String[] args) {

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

Konsolenausgabe:

In diesem Beispiel dividieren wir 33 durch 2. Als Ergebnis erhalten wir 16 und es bleibt ein zusätzlicher „Schwanz“ übrig, der nicht durch 2 teilbar ist – eins. Dieser „Schwanz“ wird das Ergebnis der Operation „Rest der Teilung“ sein. Java (wie auch Mathematik) implementiert Vergleichsoperatoren . Du kennst sie bestimmt auch aus der Schule:

gleich ( ==)
mehr ( >)
weniger ( <)
größer als oder gleich wie ( >=)
Gleich oder kleiner als ( <=)
nicht gleich ( !=)

Hier lohnt es sich, auf einen wichtigen Punkt zu achten, bei dem viele Anfänger Fehler machen. Die „gleich“-Operation wird als geschrieben ==und nicht mit einem Vorzeichen =. Das Einheitszeichen =in Java ist ein Zuweisungsoperator, bei dem einer Variablen eine Zahl, eine Zeichenfolge oder der Wert einer anderen Variablen zugewiesen wird. Zahlenoperationen in Java - 3

public class Main {

   public static void main(String[] args) {

       int x = 33;
       int y = 999;
       System.out.println(x=y);// erwarten, dass false auf der Konsole ausgegeben wird
   }
}

Konsolenausgabe:

Hoppla! Dies ist eindeutig nicht das Ergebnis, das wir erwartet hatten. Dabei handelt es sich um eine völlig andere Art von Daten: Wir hatten erwartet, zu sehen boolean, bekamen aber eine Zahl. Dies liegt daran, dass wir in Klammern eine Zuweisungsoperation und keinen Vergleich haben. x=y Der Variablen wurde der Wert y(999) zugewiesen xund wir haben ihn dann xauf der Konsole ausgegeben. Korrekte Möglichkeit:

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! :) Ein weiteres Merkmal der Zuweisungsoperation ( =) ist, dass sie „verkettet“ durchgeführt werden kann:

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:

Denken Sie daran: Die Zuordnung erfolgt von rechts nach links. Dieser Ausdruck ( x = y = z) wird in Schritten ausgeführt:

y = z, also y = 256
x = y, also x = 256

Unäre Operationen

Sie werden „unär“ genannt, abgeleitet vom Wort „uno“ – „eins“. Sie erhielten diesen Namen, weil sie im Gegensatz zu den vorherigen unter einer Nummer und nicht unter mehreren durchgeführt werden. Diese beinhalten:

Unäres Minus. Es kehrt das Vorzeichen der Zahl um.

public class Main {

   public static void main(String[] args) {

       int x = 999;

       // das Vorzeichen zum ersten Mal ändern
       x = -x;
       System.out.println(x);

       // das Vorzeichen ein zweites Mal ändern
       x= -x;
       System.out.println(x);
   }
}

Konsolenausgabe:


-999
999

Wir haben das unäre Minus zweimal verwendet. Dadurch wurde unsere Zahl zunächst negativ und dann wieder positiv!

Inkrementieren ( ++) und Dekrementieren ( --)

Eine Operation ++erhöht eine Zahl um eins und eine Operation --verringert sie um dieselbe Einheit.

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 Notationsform ist Ihnen möglicherweise bekannt, wenn Sie etwas von der Sprache C++ gehört haben. Mit Hilfe eines so interessanten Namens brachten seine Schöpfer ihre Idee zum Ausdruck: „C++ ist eine Erweiterung der C-Sprache.“ Eine beliebte verbesserte Version von Notepad heißt Notepad++ Wichtiger Punkt. Es gibt zwei Arten von Inkrementierungs- und Dekrementierungsoperationen: Postfix und Präfix. x++- Postfix-Notation ++x- Präfix-Notation Was ist der grundlegende Unterschied, wenn Sie Plus- und Minuszeichen vor oder nach der Zahl setzen? Schauen wir uns ein Beispiel an:

public class Main {

   public static void main(String[] args) {

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

Konsolenausgabe:

Stimmt etwas nicht! Wir wollten um 1 erhöhen xund der Variablen einen neuen Wert zuweisen y. Das heißt, y sollte gleich 1000 sein. Aber wir haben ein anderes Ergebnis - 999. Es stellt sich heraus, dass es xnicht erhöht wurde und die Inkrementierungsoperation nicht funktioniert hat? Wie es funktionierte. Um dies zu überprüfen, versuchen Sie am Ende, x auf der Konsole auszugeben :)

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

Aus diesem Grund wird die Postfix-Operation auch so aufgerufen: Sie wird nach dem Hauptausdruck ausgeführt. Das heißt in unserem Fall: int y = x++; Zuerst wird es ausgeführt y = x(und der Variablen y wird der Anfangswert zugewiesen x) und erst dann x++ . Was ist, wenn wir mit diesem Verhalten nicht zufrieden sind? Sie müssen 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 funktioniert es zuerst ++x und erst danach. y = x; An diesen Unterschied sollte man sich sofort erinnern, um in einem echten Programm keine Fehler zu machen, bei denen dadurch das gesamte Verhalten auf den Kopf gestellt werden kann :)

Kombinierte Operationen

Darüber hinaus gibt es in Java sogenannte kombinierte Operationen. Sie verwenden eine Kombination aus zwei Operationen:

Abtretung
Arithmetische Operation

Dazu gehören Operationen:

+=
-=
*=
/=
%=

Schauen wir uns ein Beispiel an:

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = 33;

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

Konsolenausgabe:

x += ybedeutet x = x + y. Der Kürze halber werden zwei Zeichen hintereinander verwendet. Dies funktioniert auch mit Kombinationen aus -=, und . *=/=%=

Logische Operationen

Neben Operationen mit Zahlen verfügt Java auch über Operationen mit booleschen Variablen – trueund false. Diese Operationen werden mithilfe logischer Operatoren ausgeführt

!— „NOT“-Operator. Kehrt den Wert einer booleschen Variablen um

public class Main {

   public static void main(String[] args) {

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

Konsolenausgabe:


false

&&— Operator „AND“. Gibt nur dann einen Wert zurück true, wenn beide Operanden sind true.
```
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 false, da eine der Bedingungen falsch ist, nämlich 100 > 200. Der Operator verlangt, dass alle Bedingungen wahr sind (wie zum Beispiel in der zweiten Zeile), &&um zurückzugeben .true
||— „OR“-Operator. Wird zurückgegeben true, wenn mindestens einer der Operanden wahr ist.

Hier wird unser vorheriges Beispiel anders funktionieren:
```
public class Main {

   public static void main(String[] args) {

       System.out.println(100 > 10 || 100 > 200);
   }
}
```
Konsolenausgabe:
```
true
```
Выражение 100 > 200 по-прежнему ложно, но оператору “oder” вполне достаточно, что первая часть (100 > 10) является истинной.

Kommentare

TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION