[tutoriel Java] Opérateurs Java-javaDidacticiel-php.cn

Opérateurs Java

L'une des utilisations les plus élémentaires d'un ordinateur est d'effectuer des opérations mathématiques. En tant que langage informatique, Java fournit également un riche ensemble d'opérateurs pour manipuler les variables. Nous pouvons diviser les opérateurs dans les groupes suivants :

Opérateurs arithmétiques

Opérateurs relationnels

Opérateurs au niveau du bit

Opérateurs logiques

Opérateurs d'affectation

Autres opérateurs

Opérateurs arithmétiques

Les opérateurs arithmétiques sont utilisés dans les expressions mathématiques et fonctionnent de la même manière qu'en mathématiques. Le tableau suivant répertorie tous les opérateurs arithmétiques.

L'exemple du tableau suppose que la valeur de la variable entière A est 10 et la valeur de la variable B est 20 :

Opérateur

Description

Exemple

Addition - les valeurs de part et d'autre de l'opérateur d'addition A B est égale à 30

- Soustraction - l'opérande de gauche moins les opérandes de droite A – B sont égaux à -10

* Multiplication - les valeurs des deux côtés de l'opérateur de multiplication A * B sont égales à 200

/ Division - l'opérande de gauche est divisé par l'opérande de droite B/A Égal à 2

% Modulo - le reste de l'opérande de droite divisé par l'opérande de gauche B%A est égal à 0

Auto-incrémentation - le la valeur de l'opérande augmente de 1 B est égal à 21

- Décrémentation - La valeur de l'opérande est réduite de 1 B - -Égal à 19

Exemple

Le simple suivant L'exemple de programme illustre les opérateurs arithmétiques. Copiez et collez le programme Java suivant et enregistrez-le en tant que fichier Test.java, puis compilez et exécutez le programme :

public class Test {

  public static void main(String args[]) {
     int a = 10;
     int b = 20;
     int c = 25;
     int d = 25;
     System.out.println("a + b = " + (a + b) );
     System.out.println("a - b = " + (a - b) );
     System.out.println("a * b = " + (a * b) );
     System.out.println("b / a = " + (b / a) );
     System.out.println("b % a = " + (b % a) );
     System.out.println("c % a = " + (c % a) );
     System.out.println("a++   = " +  (a++) );
     System.out.println("b--   = " +  (a--) );
     // Check the difference in d++ and ++d
     System.out.println("d++   = " +  (d++) );
     System.out.println("++d   = " +  (++d) );
  }
}

Copier après la connexion

L'exemple de compilation et les résultats d'exécution ci-dessus sont les suivants :

a + b = 30
a - b = -10
a * b = 200
b / a = 2
b % a = 0
c % a = 5
a++   = 10
b--   = 11
d++   = 25
++d   = 27

Copier après la connexion

Opérateurs relationnels

Le tableau suivant montre les opérateurs relationnels pris en charge par Java

L'exemple de variable entière A dans le tableau a une valeur de 10 et la valeur de la variable B est 20 :

Opérateur

Description

Exemple

== Vérifiez si les valeurs des deux opérandes sont égaux, si Si égal, la condition est vraie. (A == B) est faux (pas vrai).

!= Vérifie si les valeurs des deux opérandes sont égales. Si les valeurs ne sont pas égales, la condition est vraie. (A != B) est vrai.

> Vérifiez si la valeur de l'opérande de gauche est supérieure à la valeur de l'opérande de droite, si c'est le cas, la condition est vraie. (A> B) n’est pas vrai.

< Vérifiez si la valeur de l'opérande de gauche est inférieure à la valeur de l'opérande de droite, si c'est le cas, alors la condition est vraie. (A

> = Vérifiez si la valeur de l'opérande de gauche est supérieure ou égale à la valeur de l'opérande de droite, si c'est le cas alors la condition est vraie. (A> = B) est faux.

<= Vérifiez si la valeur de l'opérande de gauche est inférieure ou égale à la valeur de l'opérande de droite, si c'est le cas alors la condition est vraie. (A <= B) est vrai.

Exemple

L'exemple de programme simple suivant montre les opérateurs relationnels. Copiez et collez le programme Java suivant et enregistrez-le en tant que fichier Test.java, puis compilez et exécutez le programme :

public class Test {

  public static void main(String args[]) {
     int a = 10;
     int b = 20;
     System.out.println("a == b = " + (a == b) );
     System.out.println("a != b = " + (a != b) );
     System.out.println("a > b = " + (a > b) );
     System.out.println("a < b = " + (a < b) );
     System.out.println("b >= a = " + (b >= a) );
     System.out.println("b <= a = " + (b <= a) );
  }
}

Copier après la connexion

Les résultats de compilation et d'exécution de l'exemple ci-dessus sont les suivants :

a == b = false
a != b = true
a > b = false
a < b = true
b >= a = true
b <= a = false

Copier après la connexion

Opérateurs au niveau du bit

Java définit des opérateurs au niveau du bit, qui sont appliqués aux types entiers (int), entier long (long), entier court (short), type de caractère (char) et type d'octet ( octet).

Les opérateurs au niveau du bit opèrent sur tous les bits et fonctionnent au niveau du bit. Supposons que a = 60 et b = 13 ; leur représentation au format binaire sera la suivante :

A = 0011 1100
B = 0000 1101
-----------------
A&b = 0000 1100
A | B = 0011 1101
^ B = 0011 0001
~A= 1100 0011

Copier après la connexion

Le tableau suivant répertorie les opérations de base des opérateurs de bits, en supposant que la valeur de la variable entière A est 60 et variable B La valeur est 13 :

Opérateur

Description

Exemple

& Opérateur AND au niveau du bit, le résultat sera 1 si et seulement si un certain bit des deux opérandes est non-0. (A&B), obtenez 12, soit 0000 1100

| Opérateur OU au niveau du bit, tant que l'un des deux opérandes a un non-0, le bit de résultat sera 1. (A | B) obtient 61, soit 0011 1101

^ 按位异或操作符，两个操作数的某一位不相同时候结果的该位就为1。（A ^ B）得到49，即 0011 0001

〜按位补运算符翻转操作数的每一位。（〜A）得到-60，即1100 0011

<< 按位左移运算符。左操作数按位左移右操作数指定的位数。 A << 2得到240，即 1111 0000

>> 按位右移运算符。左操作数按位右移右操作数指定的位数。 A >> 2得到15即 1111

>>> 按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。 A>>>2得到15即0000 1111

实例

下面的简单示例程序演示了位运算符。复制并粘贴下面的Java程序并保存为Test.java文件，然后编译并运行这个程序：

public class Test {
  public static void main(String args[]) {
     int a = 60; /* 60 = 0011 1100 */ 
     int b = 13; /* 13 = 0000 1101 */
     int c = 0;
     c = a & b;       /* 12 = 0000 1100 */
     System.out.println("a & b = " + c );

     c = a | b;       /* 61 = 0011 1101 */
     System.out.println("a | b = " + c );

     c = a ^ b;       /* 49 = 0011 0001 */
     System.out.println("a ^ b = " + c );

     c = ~a;          /*-61 = 1100 0011 */
     System.out.println("~a = " + c );

     c = a << 2;     /* 240 = 1111 0000 */
     System.out.println("a << 2 = " + c );

     c = a >> 2;     /* 215 = 1111 */
     System.out.println("a >> 2  = " + c );
  
     c = a >>> 2;     /* 215 = 0000 1111 */
     System.out.println("a >>> 2 = " + c );
  }
}

Copier après la connexion

以上实例编译运行结果如下：

a & b = 12
a | b = 61
a ^ b = 49
~a = -61
a << 2 = 240
a >> 15
a >>> 15

Copier après la connexion

逻辑运算符

下表列出了逻辑运算符的基本运算，假设布尔变量A为真，变量B为假

操作符

描述

例子

&& 称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。（A && B）为假。

| | 称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。（A | | B）为真。

！称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。！（A && B）为真。

实例

下面的简单示例程序演示了逻辑运算符。复制并粘贴下面的Java程序并保存为Test.java文件，然后编译并运行这个程序：

public class Test {
  public static void main(String args[]) {
     boolean a = true;
     boolean b = false;
     System.out.println("a && b = " + (a&&b));
     System.out.println("a || b = " + (a||b) );
     System.out.println("!(a && b) = " + !(a && b));
  }
}

Copier après la connexion

以上实例编译运行结果如下：

a && b = false
a || b = true
!(a && b) = true

Copier après la connexion

赋值运算符

下面是Java语言支持的赋值运算符：

操作符

描述

例子

= 简单的赋值运算符，将右操作数的值赋给左侧操作数 C = A + B将把A + B得到的值赋给C

+ = 加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数 C + = A等价于C = C + A

- = 减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数 C - = A等价于C = C -
A

* = 乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数 C * = A等价于C = C * A

/ = 除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数 C / = A等价于C = C / A

（％）= 取模和赋值操作符，它把左操作数和右操作数取模后赋值给左操作数 C％= A等价于C = C％A

<< = 左移位赋值运算符 C << = 2等价于C = C << 2

>> = 右移位赋值运算符 C >> = 2等价于C = C >> 2

＆= 按位与赋值运算符 C＆= 2等价于C = C＆2

^ = 按位异或赋值操作符 C ^ = 2等价于C = C ^ 2

| = 按位或赋值操作符 C | = 2等价于C = C | 2

实例

面的简单示例程序演示了赋值运算符。复制并粘贴下面的Java程序并保存为Test.java文件，然后编译并运行这个程序：

public class Test {
  public static void main(String args[]) {
     int a = 10;
     int b = 20;
     int c = 0;
     c = a + b;
     System.out.println("c = a + b = " + c );
     c += a ;
     System.out.println("c += a  = " + c );
     c -= a ;
     System.out.println("c -= a = " + c );
     c *= a ;
     System.out.println("c *= a = " + c );
     a = 10;
     c = 15;
     c /= a ;
     System.out.println("c /= a = " + c );
     a = 10;
     c = 15;
     c %= a ;
     System.out.println("c %= a  = " + c );
     c <<= 2 ;
     System.out.println("c <<= 2 = " + c );
     c >>= 2 ;
     System.out.println("c >>= 2 = " + c );
     c >>= 2 ;
     System.out.println("c >>= a = " + c );
     c &= a ;
     System.out.println("c &= 2  = " + c );
     c ^= a ;
     System.out.println("c ^= a   = " + c );
     c |= a ;
     System.out.println("c |= a   = " + c );
  }
}

Copier après la connexion

以上实例编译运行结果如下：

c = a + b = 30
c += a  = 40
c -= a = 30
c *= a = 300
c /= a = 1
c %= a  = 5
c <<= 2 = 20
c >>= 2 = 5
c >>= 2 = 1
c &= a  = 0
c ^= a   = 10
c |= a   = 10

Copier après la connexion

条件运算符（?:）

条件运算符也被称为三元运算符。该运算符有3个操作数，并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。

variable x = (expression) ? value if true : value if false

Copier après la connexion

实例

public class Test {
   public static void main(String args[]){
      int a , b;   
      a = 10;    
b = (a == 1) ? 20: 30;    
System.out.println( "Value of b is : " +  b );
      b = (a == 10) ? 20: 30;    
     System.out.println( "Value of b is : " + b );
   }

Copier après la connexion

以上实例编译运行结果如下：

Value of b is : 30
Value of b is : 20

Copier après la connexion

instanceOf 运算符

该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）。

instanceof运算符使用格式如下：

( Object reference variable ) instanceOf  (class/interface type)

Copier après la connexion

如果运算符左侧变量所指的对象，是操作符右侧类或接口(class/interface)的一个对象，那么结果为真。

下面是一个例子：

String name = &#39;James&#39;;
boolean result = name instanceOf String; // 由于name是Strine类型，所以返回真

Copier après la connexion

如果被比较的对象兼容于右侧类型,该运算符仍然返回true。

看下面的例子：

class Vehicle {}

public class Car extends Vehicle {
   public static void main(String args[]){
      Vehicle a = new Car();
      boolean result =  a instanceof Car;
      System.out.println( result);
   }
}

Copier après la connexion

以上实例编译运行结果如下：