Basisbetreiber in Java | Erklärt
Zum Beispiel die Java -Betreiber, die Addition, Subtraktion, Abteilung, Multiplikation usw. durchführen, usw. werden in die arithmetische Kategorie von Operatoren platziert. In ähnlicher Weise werden die Operatoren, die die Beziehung zwischen Variablen anbieten.
Dieser Artikel listet die Verwendung und Anwendbarkeit der Basisbetreiber in Java auf. So lass uns anfangen.
Was sind die Grundbetreiber in Java?
Dieser Abschnitt beschreibt die Funktionalität grundlegender Operatoren in Java.
Zuordnungsbetreiber
Diese Betreiber helfen dabei, eine Variable in Java Wert zuzuweisen. Diese Zuordnungsaktion kann mit einem der folgenden Operatoren durchgeführt werden:
"=": Arbeitet an zwei Operanden und weist den Wert auf der rechten Seite der auf der linken Seite geschriebenen Variablen zu.
"+=": Fügt Operanden beider Seiten hinzu und weist dann den Wert der Variablen auf der linken Seite zu
"-=": Subtrahiert Operand von links nach rechts und weist dann den Wert der auf der linken Seite platzierten Variablen zu
"*=": multipliziert beide Operanden und weist dann die Antwort der Variablen auf der linken Seite zu
"/=": meldet den Rest, indem Sie die Operanden dividieren oder den linken Operanden durch einen bestimmten Wert teilen.
"%=": Erhält den Rest mit diesem % zuerst, und dann wird die Antwort der Variablen auf der linken Seite zugewiesen.
Die folgenden Syntaxen können befolgt werden:
Operand1 = Operandd2; // verwendet =Operand1 += operand2 // mit +=
Operand1- = Operand2 // verwenden -=
Operand1 *= Operand2 // verwenden *=
Operand1 /= operand2 // verwenden /=
Operand1 %= operand2 // mit %=
Rechenzeichen
Diese Kategorie befasst sich mit den arithmetischen Operationen und die folgenden Operatoren befinden sich in dieser Kategorie.
"+": Wird verwendet, um zwei Variablen/Werte hinzuzufügen
"-": liefert die Differenz zwischen zwei Variablen/Wert
"*": multipliziert zwei Variablen/Werte
"/": Wird verwendet, um eine Variable über eine andere zu teilen, und der Quotient wird in der Ausgabe angezeigt.
"%": meldet den Rest () von zwei Variablen/Werten
Die Syntax dieser Operatoren ist nachstehend bereitgestellt. Operand1 und Operand2 beziehen sich auf die Variablen/Werte. Es wird beobachtet, dass zwei Operanden arithmetische Operationen durchführen müssen.
Operand1+Operand2; //ZusatzOperand1-operand2; //Subtraktion
Operand1*Operand2; //Multiplikation
Operand1/Operand2; //Aufteilung
Operand1%Operand2; //Rest
Unary Operatoren
Dieser Typ führt verschiedene Vorgänge für eine Variable/einen Variablen aus. Die in dieser Kategorie enthaltenen Betreiber werden nachstehend beschrieben:
"+": Zuweist einem Operanden ein positives Zeichen (normalerweise wird ein positives Zeichen nicht angezeigt, da es optional ist)
"-": ändert das Zeichen eines Operanden
"++": erhöht den Wert eines Operanden um 1. Der Inkrementoperator kann als Postfix und Präfix angewendet werden
"-": Der Wert einer Variablen/eines Wertes wird durch 1 verringert. Wie Inkrement kann es auch als Präfix oder Postfix verwendet werden
“!”: Der Boolesche Wert (True/False) wird durch die Verwendung dieses Bedieners invertiert
Sie können sich auf die unten angegebene Syntax dieser Operatoren beziehen:
+Operand; // Unary Plus-Operand; // Unary Minus
++Operand; // Präfixinkrement
Operand ++; // Postfix -Inkrement
Operand--; // Postfix -Abnahme
--Operand; // Präfix -Abnahme
!Operand; // logische Ergänzung
Logische Operatoren
Diese Operatoren helfen bei der Durchführung logischer Operationen wie und, oder und nicht. Diese werden unten beschrieben:
UND(&&): Dies funktioniert auf zwei Variablen/Werten. Es gibt true zurück, wenn beide Variablen in anderen Fällen wahr und falsch sind.
Oder (||): Dieser Operator erstellt Logik so, dass, wenn beide Werte falsch sind, das Ergebnis falsch wäre, sonst wahr ist.
NICHT (!): Dies bezieht sich auch auf die Unary -Kategorie und gibt falsche/wahre Ergebnisse zurück
Sie können sich auf die folgenden Syntaxen beziehen, um logische Operatoren zu verwenden:
Operand1 && operand2 // logisch undOperand1 || Operand2 // logisch oder
!Operand // logisch nicht
Bitgewise -Operatoren
Die Klasse dieses Betreibers befasst sich mit den Binärwerten und somit werden alle Operationen Stück für Stück durchgeführt. und die folgenden Betreiber werden geübt:
"&": Dies ist als binär bekannt und das funktioniert genauso wie logisch und aber auf binären Werte.
"|": Dies funktioniert auch auf dem gleichen Muster wie logisch oder, aber es führt die Operation für Stück aus.
"^": Dies wird als XOR bezeichnet. Es kehrt true zurück, wenn beide Werte unterschiedlich sind und falsche zurückgeben, wenn beide Werte gleich sind.
"~": Dieser Bediener ändert das Bit von 0 bis 1 und 1 bis 0
“<<“: Dieser linke Schaltoperator verschiebt die Anzahl der Bits nach links. Die Anzahl der Bits wird vom Benutzer festgelegt und kann eine beliebige Zahl sein.
">>": Der rechte Schaltoperator verschiebt wird die Anzahl der Bits von der rechten Seite entfernt.
">>>": Dies wird als ununterdrückte rechte Verschiebung bezeichnet und verschiebt die Anzahl der Bits um „0“
Die folgenden Syntaxe beziehen sich auf die bitgewiellen Operatoren:
Operand1 | Operand2; // bitweise oderOperand1 & Operand2; // bitweise und
Operand1 ^ operand2; // bitweise xor
~ Operand; // bitweise Ergänzung
Operand<
Operand >>> Nummer; // bitweise unsignierte rechte Verschiebung
Relationale Operatoren
Diese Kategorie bezieht sich auf die Beziehung zwischen mehr als einer Variablen unter Verwendung spezifischer Symbole. Diese Betreiber helfen bei der Entscheidung in der Java -Programmierung.
"==": Dieser Betreiber praktiziert die Gleichheit von zwei Operanden
“!= ”: verwendet, um zu überprüfen, ob die Ungleichheit der Operanden
“<“: Übte, weniger als die Beziehung zwischen zwei Operanden zu überprüfen
">": Es wird verwendet, um zu überprüfen, ob der linke Operand höher ist oder nicht
"> =": zu überprüfen, ob der linke Operand nach rechts „größer oder gleich“ ist oder nicht
“<=”: Es wird geübt, ob die linke Variable kleiner oder gleich dem rechten ist
Die relationalen Operatoren können mithilfe der unten angegebenen Syntaxen praktiziert werden:
Operand1 == Operand2; //gleichOperand1!= Operand2; //Nicht gleichzusetzen mit
Operand1> Operand2; //größer als
Operand1
Operand1<=operand2; //less than or equal to
So verwenden Sie grundlegende Operatoren in Java
Dieser Abschnitt bietet die Verwendung grundlegender Betreiber in Java. Jedes Beispiel demonstriert den Java -Code, der Operatoren einer bestimmten Kategorie verwendet.
Beispiel 1: Verwenden der Zuordnungsoperatoren
Die folgenden Java -Code üben verschiedene Zuordnungsbetreiber für Variablen aus.
Paket Newpack;öffentliche Klassenzuweisungen
public static void main (String [] args)
// verwendet "=" zu Zuordnungswerte
int a = 3, b = 4, c = 5, d = 6, e = 7;
// verwenden "+=" auf a
a+= 3;
System.aus.println ("neuer Wert von a wäre:" +a);
// verwendet "-=" auf B
B- = 3;
System.aus.println ("neuer Wert von B wäre:" +B);
// mit "*=" auf c
C*= 2;
System.aus.println ("neuer Wert von C wäre:" +c);
// mit "/=" auf d
d/= 2;
System.aus.println ("neuer Wert von D wäre:" +d);
// "%=" auf e
e%= 2;
System.aus.println ("neuer Wert von E wäre:" +e);
Der oben festgelegte Code wird hier beschrieben:
- Erstens werden die Werte Variablen zugewiesen = =
- Die Anweisung „A+= 3“ fügt 3 zum aktuellen Wert von a hinzu
- Subtrahieren 3 von B mit „-=“
- multipliziert den Wert von C mit 2 mit "*=" mit 2, indem Sie "*="
- Teilen Sie den Wert von D durch 2 mit "/=" unterteilt
- Der Wert von E wird durch 2 geteilt und dann wird der Rest als neuer Wert von e gespeichert.
Die Ausgabe des Codes wird unten angegeben:
Beispiel 2: Verwenden von arithmetischen Operatoren
Der folgende Java -Code führt arithmetische Operationen auf zwei Zahlen a = 5 und b = 11 aus.
Paket Newpack;öffentliche Klasse Arithop
public static void main (String [] args)
// Variablen initialisieren
int a = 5, b = 11;
// + auf a und b verwenden
System.aus.println ("a+b ="+(a+b));
// Verwenden - auf A und B
System.aus.println ("a-b =" + (a-b));
// mit * auf a und b verwenden
System.aus.println ("a-b =" + (a*b));
// Verwenden /auf a und b
System.aus.println ("a/b =" + (b/a));
// % auf A und B verwenden
System.aus.println ("a%b =" + (a%b));
Im obigen Code werden die Variablen zuerst initialisiert und dann repräsentiert jede Zeile die Anwendung eines anderen Zuordnungsoperators.
Die Ausgabe ist unten angegeben:
Beispiel 3: Verwenden von relationalen Operatoren
Der folgende Java -Code übt die relationalen Operatoren in zwei Variablen x = 3 und y = 5.
Paket Newpack;öffentliche Klasse Rellop
public static void main (String [] args)
// Variablen initialisieren
int x = 3, y = 5;
// benutze < operator
System.aus.println ("ist x weniger als y? " + (X -Operator
System.aus.println ("ist x größer als y? " + (x> y));
// using == Operator
System.aus.println ("ist x gleich y? " + (x == y));
Der oben geschriebene Code implementiert drei relationale Operatoren auf x und y. Darüber hinaus wird der Code als:
- Initialisiert zwei Variablen x und y
- meldet das Ergebnis von x
- druckt wahre oder falsche Ergebnisse für die Bedingung x> y
- Überprüft und druckt die Gleichheit von x und y
Die Ausgabe des Codes wird unten angegeben:
Beispiel 4: Verwenden von logischen Operatoren
Der folgende Java-Code übt die logischen Operatoren in if-else-bedingter Anweisung aus.
Paket Newpack;öffentliche Klasse Logop
public static void main (String [] args)
int a = 4, b = 5, c = 5;
if (a == b || (b == c && c!= a))
System.aus.println ("Die Bedingung ist wahr");
anders
System.aus.println ("Die Bedingung ist falsch");
Der obige Code wird als beschrieben als.
- Drei Variablen werden initialisiert
- In der IF -Bedingung haben wir den und (&&) Operator zwischen b == c und c verwendet!= a. Darüber hinaus wird diese Aussage mit A == B verwendet oder (||) Operator.
- Die oben genannte Bedingung ist wahr, daher würde der If-Block der IF-ELSE-Anweisung ausgeführt werden.
Die Ausgabe des Codes ist im Bild unten angezeigt:
Beispiel 5: Verwenden von Unary Operatoren
Die Unary -Betreiber werden im folgenden Java -Code praktiziert.
Paket Newpack;öffentliche Klasse Unop
public static void main (String [] args)
// Variablen initialisieren
int a = 4, b = 6;
// Unary minus auf a
System.aus.println ("Aktualisierter Wert von a ist:" + (-a));
// Verwenden des Präfixinkrements auf B
System.aus.println ("Aktualisierter Wert von B ist:"+(++ b));
Die Beschreibung des Codes lautet:
- Zwei Variablen A und B werden initialisiert
- druckt die Antwort, nachdem sie Unary minus auf a beantragt haben
- Zeigt das Ergebnis nach Anwendung des Präfix -Inkrement -Operators auf B an
Die Ausgabe des Codes wird hier bereitgestellt:
Beispiel 6: Verwenden von Bitwise -Operatoren
Der folgende Java -Code implementiert mehrere Bitgewise -Operatoren für Variablen/Werte.
Paket Newpack;öffentliche Klasse Bitop
public static void main (String [] args)
int a = 3, b = 5;
// Bitwise links Shift Operator auf a
System.aus.println ("Die Antwort lautet:" + (a3));
Der Code wird beschrieben als:
- A- und B -Variablen werden initialisiert
- benutzte den linken Schaltbetreiber auf A und die Antwort wird gedruckt. Die Binärin von Nummer 3 würde von 2Bits nach links verschoben werden.
- druckt die Antwort, nachdem Sie den richtigen Schaltoperator auf B angewendet haben. Die 3bits von Nummer B würden von der rechten Seite der Binärzahl von Nummer 3 entfernt.
Die Ausgabe des Codes ist:
Abschluss
Die grundlegenden Betreiber in Java sind die Betreiber, die häufig in Java -Programmen verwendet werden. Java unterstützt eine lange Liste von Betreibern, die bei der Durchführung verschiedener Operationen für Variablen/Werte helfen. Die Betreiber mit gleicher Anwendbarkeit werden in derselben Kategorie platziert. Zum Beispiel können die Operatoren, die die Beziehungen definieren. In diesem Artikel werden die grundlegenden Betreiber in Java aufgeführt und ihre Anwendung mit Java -Code bereitgestellt. Sie hätten den Überblick und die vorläufige Anwendbarkeit aller grundlegenden Operatoren in Java gelernt.