Java-operators

In deze zelfstudie leert u met behulp van voorbeelden over verschillende soorten operators in Java, hun syntaxis en hoe u ze kunt gebruiken.

Operators zijn symbolen die bewerkingen uitvoeren op variabelen en waarden. Bijvoorbeeld + is een operator die wordt gebruikt voor optellen, terwijl * is ook een operator die wordt gebruikt voor vermenigvuldiging.

Operators in Java kunnen worden ingedeeld in 5 typen:

Rekenkundige operatoren
Opdrachtoperators
Relationele operators
Logische operators
Unaire operators
Bitwise-operators

1. Java rekenkundige operatoren

Rekenkundige operatoren worden gebruikt om rekenkundige bewerkingen op variabelen en gegevens uit te voeren. Bijvoorbeeld,

a + b;

Hier, de + operator wordt gebruikt om twee variabelen toe te voegen a en b . Evenzo zijn er verschillende andere rekenkundige operatoren in Java.

Operator	Bewerking
`+`	Toevoeging
`-`	Aftrekken
`*`	Vermenigvuldigen
`/`	Divisie
`%`	Modulo-bediening (rest na deling)

Voorbeeld 1:rekenkundige operatoren

class Main {
  public static void main(String[] args) {
    
    // declare variables
    int a = 12, b = 5;

    // addition operator
    System.out.println("a + b = " + (a + b));

    // subtraction operator
    System.out.println("a - b = " + (a - b));

    // multiplication operator
    System.out.println("a * b = " + (a * b));

    // division operator
    System.out.println("a / b = " + (a / b));

    // modulo operator
    System.out.println("a % b = " + (a % b));
  }
}

Uitvoer

a + b = 17
a - b = 7 
a * b = 60
a / b = 2 
a % b = 2

In het bovenstaande voorbeeld hebben we + . gebruikt , - , en * operatoren om bewerkingen voor optellen, aftrekken en vermenigvuldigen te berekenen.

/ Divisie-operator

Let op de bewerking, a / b in ons programma. De / operator is de delingsoperator.

Als we de delingsoperator gebruiken met twee gehele getallen, dan is het resulterende quotiënt ook een geheel getal. En als een van de operanden een getal met drijvende komma is, krijgen we dat het resultaat ook in drijvende komma is.

In Java,

(9 / 2) is 4
(9.0 / 2) is 4.5
(9 / 2.0) is 4.5
(9.0 / 2.0) is 4.5

% Modulo-operator

De modulo-operator % berekent de rest. Wanneer a = 7 wordt gedeeld door b = 4 , de rest is 3 .

Opmerking :De % operator wordt voornamelijk gebruikt met gehele getallen.

2. Java-toewijzingsoperators

Toewijzingsoperators worden in Java gebruikt om waarden aan variabelen toe te wijzen. Bijvoorbeeld,

int age;
age = 5;

Hier, = is de toewijzingsoperator. Het wijst de waarde aan de rechterkant toe aan de variabele aan de linkerkant. Dat wil zeggen, 5 wordt toegewezen aan de variabele leeftijd .

Laten we eens kijken wat meer toewijzingsoperators beschikbaar zijn in Java.

Operator	Voorbeeld	Equivalent aan
`=`	`a = b;`	`a = b;`
`+=`	`a += b;`	`a = a + b;`
`-=`	`a -= b;`	`a = a - b;`
`*=`	`a *= b;`	`a = a * b;`
`/=`	`a /= b;`	`a = a / b;`
`%=`	`a %= b;`	`a = a % b;`

Voorbeeld 2:Toewijzingsoperators

class Main {
  public static void main(String[] args) {
    
    // create variables
    int a = 4;
    int var;

    // assign value using =
    var = a;
    System.out.println("var using =: " + var);

    // assign value using =+
    var += a;
    System.out.println("var using +=: " + var);

    // assign value using =*
    var *= a;
    System.out.println("var using *=: " + var);
  }
}

Uitvoer

var using =: 4
var using +=: 8 
var using *=: 32

3. Java-relationele operators

Relationele operatoren worden gebruikt om de relatie tussen twee operanden te controleren. Bijvoorbeeld,

// check if a is less than b
a < b;

Hier, < operator is de relationele operator. Het controleert of een is kleiner dan b of niet.

Het retourneert ofwel true of false .

Operator	Beschrijving	Voorbeeld
`==`	Is gelijk aan	`3 == 5` retourneert false
`!=`	Niet gelijk aan	`3 != 5` retourneert true
`>`	Groter dan	`3 > 5` retourneert false
`<`	Minder dan	`3 < 5` retourneert true
`>=`	Groter dan of gelijk aan	`3 >= 5` retourneert false
`<=`	Minder dan of gelijk aan	`3 <= 5` retourneert true

Voorbeeld 3:relationele operators

class Main {
  public static void main(String[] args) {
    
    // create variables
    int a = 7, b = 11;

    // value of a and b
    System.out.println("a is " + a + " and b is " + b);

    // == operator
    System.out.println(a == b);  // false

    // != operator
    System.out.println(a != b);  // true

    // > operator
    System.out.println(a > b);  // false

    // < operator
    System.out.println(a < b);  // true

    // >= operator
    System.out.println(a >= b);  // false

    // <= operator
    System.out.println(a <= b);  // true
  }
}

Opmerking :Relationele operatoren worden gebruikt bij besluitvorming en lussen.

4. Logische Java-operators

Logische operatoren worden gebruikt om te controleren of een uitdrukking true . is of false . Ze worden gebruikt bij het nemen van beslissingen.

Operator	Voorbeeld	Betekenis
`&&` (Logische EN)	expressie1 && expressie2	`true` alleen als beide `expressie1` en `expression2` zijn `true`
`\|\|` (Logische OF)	expression1 \|\| expressie2	`true` als een van beide `expressie1` of `expressie2` is `true`
`!` (Logisch NIET)	! uitdrukking	`true` if `uitdrukking` is `false` en vice versa

Voorbeeld 4:Logische operators

class Main {
  public static void main(String[] args) {

    // && operator
    System.out.println((5 > 3) && (8 > 5));  // true
    System.out.println((5 > 3) && (8 < 5));  // false

    // || operator
    System.out.println((5 < 3) || (8 > 5));  // true
    System.out.println((5 > 3) || (8 < 5));  // true
    System.out.println((5 < 3) || (8 < 5));  // false

    // ! operator
    System.out.println(!(5 == 3));  // true
    System.out.println(!(5 > 3));  // false
  }
}

Werking van het programma

(5 > 3) && (8 > 5) retourneert true omdat beide (5 > 3) en (8 > 5) zijn true .
(5 > 3) && (8 < 5) retourneert false omdat de uitdrukking (8 < 5) is false .
(5 < 3) || (8 > 5) retourneert true omdat de uitdrukking (8 > 5) is true .
(5 > 3) && (8 > 5) retourneert true omdat de uitdrukking (5 > 3) is true .
(5 > 3) && (8 > 5) retourneert false omdat beide (5 < 3) en (8 < 5) zijn false .
!(5 == 3) geeft true terug omdat 5 == 3 is false .
!(5 > 3) retourneert false omdat 5 > 3 is true .

5. Java Unary-operators

Unaire operatoren worden gebruikt met slechts één operand. Bijvoorbeeld ++ is een unaire operator die de waarde van een variabele met 1 . verhoogt . Dat wil zeggen, ++5 retourneert 6 .

Verschillende soorten unaire operatoren zijn:

Operator	Betekenis
`+`	Unair plus :niet nodig om te gebruiken omdat getallen positief zijn zonder het te gebruiken
`-`	Unaire min :keert het teken van een uitdrukking om
`++`	Ophogingsoperator :waarde met 1 verhogen
`--`	operator verlagen :waarde met 1 verlagen
`!`	Logische complement-operator :keert de waarde van een boolean om

operators verhogen en verlagen

Java biedt ook increment- en decrement-operators:++ en -- respectievelijk. ++ verhoogt de waarde van de operand met 1 , terwijl -- verlaag het met 1 . Bijvoorbeeld,

int num = 5;

// increase num by 1
++num;

Hier, de waarde van num wordt verhoogd tot 6 vanaf de beginwaarde van 5 .

Voorbeeld 5:Operators verhogen en verlagen

class Main {
  public static void main(String[] args) {
    
    // declare variables
    int a = 12, b = 12;
    int result1, result2;

    // original value
    System.out.println("Value of a: " + a);

    // increment operator
    result1 = ++a;
    System.out.println("After increment: " + result1);

    System.out.println("Value of b: " + b);

    // decrement operator
    result2 = --b;
    System.out.println("After decrement: " + result2);
  }
}

Uitvoer

Value of a: 12
After increment: 13
Value of b: 12     
After decrement: 11

In het bovenstaande programma hebben we de operator ++ en -- gebruikt als prefixen (++a, --b) . We kunnen deze operatoren ook gebruiken als postfix (a++, b++) .

Er is een klein verschil wanneer deze operators als prefix worden gebruikt en wanneer ze als postfix worden gebruikt.

Ga voor meer informatie over deze operatoren naar operatoren voor verhogen en verlagen.

6. Java Bitwise-operators

Bitwise-operators in Java worden gebruikt om bewerkingen op afzonderlijke bits uit te voeren. Bijvoorbeeld,

Bitwise complement Operation of 35

35 = 00100011 (In Binary)

~ 00100011 
  ________
   11011100  = 220 (In decimal)

Hier, ~ is een bitsgewijze operator. Het keert de waarde van elke bit om (0 tot 1 en 1 tot 0 ).

De verschillende bitsgewijze operators die aanwezig zijn in Java zijn:

Operator	Beschrijving
`~`	Bitsgewijze aanvulling
`<<`	Linker Shift
`>>`	Rechts Shift
`>>>`	Niet-ondertekende verschuiving naar rechts
`&`	Bitwise EN
`^`	Bitwise exclusief OF

Deze operators worden over het algemeen niet gebruikt in Java. Ga voor meer informatie naar Java Bitwise en Bit Shift Operators.

Andere operators

Naast deze operators zijn er nog andere extra operators in Java.

Java-instantie van Operator

De instanceof operator controleert of een object een instantie is van een bepaalde klasse. Bijvoorbeeld,

class Main {
  public static void main(String[] args) {

    String str = "Programiz";
    boolean result;

    // checks if str is an instance of
    // the String class
    result = str instanceof String;
    System.out.println("Is str an object of String? " + result);
  }
}

Uitvoer

Is str an object of String? true

Hier, str is een instantie van de String klas. Vandaar dat de instanceof operator retourneert true . Ga voor meer informatie naar Java instanceof.

Java ternaire operator

De ternaire operator (voorwaardelijke operator) is een afkorting voor de if-then-else uitspraak. Bijvoorbeeld,

variable = Expression ? expression1 : expression2

Zo werkt het.

Als de Expression is true , expression1 wordt toegewezen aan de variabele .
Als de Expression is false , expression2 wordt toegewezen aan de variabele .

Laten we eens kijken naar een voorbeeld van een ternaire operator.

class Java {
  public static void main(String[] args) {

    int februaryDays = 29;
    String result;

    // ternary operator
    result = (februaryDays == 28) ? "Not a leap year" : "Leap year";
    System.out.println(result);
  }
}

Uitvoer

Leap year

In het bovenstaande voorbeeld hebben we de ternaire operator gebruikt om te controleren of het jaar een schrikkeljaar is of niet. Ga voor meer informatie naar de ternaire Java-operator.

Nu u meer weet over Java-operators, is het tijd om te weten in welke volgorde operators worden geëvalueerd. Ga voor meer informatie naar Java Operator Precedence.

Java-gegevenstypen (primitief) Java basis invoer en uitvoer

Java