Descripteur
Les descripteurs sont des mots clés que vous ajoutez à ces définitions pour modifier leur sens. La langue Java a de nombreux descripteurs, y compris les éléments suivants:
classe publique classe classname {// ...} private boolean myflag; static final doubles semaines = 9,5; protégé statique final int boxwidth = 42; public static void main (string [] arguments) {// corps de méthode} Descripteurs accessibles
Java fournit une série de descripteurs accessibles pour définir les niveaux d'accès des classes, des variables, des méthodes et des constructeurs. Les quatre niveaux d'accès sont les suivants:
Par défaut, visible à l'encapsulation. Aucun descripteur n'est requis.
Descripteur inaccessible
Java fournit des descripteurs inaccessibles pour satisfaire d'autres fonctions.
Opérateurs de base
Java fournit un riche ensemble d'opérateurs pour manipuler les variables. Nous pouvons diviser tous les opérateurs Java en groupes suivants:
L'utilisation d'opérateurs arithmétiques dans les expressions mathématiques est la même que leur utilisation dans l'algèbre. Le tableau suivant répertorie les opérateurs arithmétiques:
En supposant qu'il existe 10 variables globales A et 20 variables B, puis:
Exemple
| Opérateurs | décrire | exemple |
|---|---|---|
| + | L'ajout est ajouté à l'autre extrémité de l'opérateur | A + B est 30 |
| - | La soustraction soustrait l'opérande à droite de l'opérande à gauche | A - B est -10 |
| * | La multiplication multiplie les valeurs aux deux extrémités de l'opérateur | A * B est 200 |
| / / | Divisez l'opérande gauche par l'opérande droit | B / A est 2 |
| % | Coefficient - Divisez l'opérande gauche avec l'opérande droit et retournez le reste | B% a est 0 |
| ++ | L'incrément augmente la valeur de l'opérande de 1 | B ++ est 21 |
| - | Dismente soustrait 1 à la valeur de l'opérande | B-IS 19 |
Exemple
| Opérateurs | décrire | exemple |
|---|---|---|
| == | Vérifiez si les valeurs des opérandes des deux côtés sont égales. S'ils sont égaux, la condition est vraie. | (A == b) Pas vrai. |
| ! = | Vérifiez si les valeurs des opérandes des deux côtés sont égales. Si ce n'est pas égal, la condition est vraie. | (A! = B) est vrai. |
| > | Vérifiez si l'opérande de gauche est supérieur à l'opérande à droite. Si c'est plus grand, la condition est vraie | (A> b) Pas vrai. |
| < | Vérifiez si l'opérande à gauche est plus petit que l'opérande à droite. S'il est plus petit, alors la condition est vraie | (A <b) est vrai. |
| > = | Vérifiez que l'opérande de gauche est supérieur ou égal à l'opérande à droite. Si c'est le cas, la condition est vraie | (A> = b) Pas vrai. |
| <= | Vérifiez si l'opérande à gauche est inférieur ou égal à l'opérande à droite. Si c'est le cas, la condition est vraie | (A <= b) est vrai. |
L'opérateur de bits agit sur les normes de transmission entre les systèmes binaires et effectue des opérations bit Supposons si A est égal à 60; B est égal à 13; Maintenant sous forme binaire, ils sont les suivants:
A = 0011 1100B = 0000 1101 --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
La table suivante répertorie les opérateurs de bits:
Supposons qu'il existe 60 variables entières A et 13 B, puis:
Exemple
| Opérateurs | décrire | exemple |
|---|---|---|
| & | Binaire et opérateur en copier un sur le résultat si les deux opérandes existent en même temps | (A&B) est 12, c'est-à-dire 0000 1100 |
| | | Le binaire ou l'opérateur copie un peu sur le résultat s'il existe sur un opérande | (A | b) est 61, c'est-à-dire 0011 1101 |
| ^ | L'opérateur binaire XOR copie le bit s'il est réglé sur un opérande au lieu de deux. | (A ^ b) est 49, c'est-à-dire 0011 0001 |
| ~ | L'opérateur de supplément binaire est unary et B a l'effet de bits "flip" | (~ A) est -61. Puisqu'il s'agit d'un numéro binaire signé, la forme de complément de 2 est 1100 0011 |
| << | Opérateur de quart de travail binaire à gauche. La valeur de l'opérande à gauche se déplace vers la gauche en fonction du nombre de bits spécifiés par l'opérande à droite. | A << 2 est 240, c'est-à-dire 1111 0000 |
| >> | Opérateur de changement de droite binaire. La valeur de l'opérande à gauche se déplace vers la droite en fonction du nombre de bits spécifiés par l'opérande à droite. | A >> 2 est 15, c'est-à-dire 1111 |
| >>> | Déplacez à droite pour remplir l'opérateur zéro. La valeur de l'opérande gauche est déplacée vers la droite en fonction du nombre de bits spécifiés par l'opérande de droite, et la valeur transférée est remplie de zéro. | A >>> 2 est 15, c'est-à-dire 0000 1111 |
En supposant que la variable booléenne du système mathématique a est vraie et b est fausse, alors:
Exemple
| Opérateurs | décrire | exemple |
|---|---|---|
| && | Il est appelé logique et opérateur. Si les deux opérandes ne sont pas nuls, la condition est vraie. | (A && b) est vrai. |
| || | Appelé logique ou opérateur. Si aucun des opérandes n'est nul, la condition est vraie. | (A || b) est vrai. |
| ! | Appelé un non-opérateur logique. Il est utilisé comme état logique des opérandes de bascule. Si une condition est vraie, alors le non-opérateur logique est faux. | ! (A && b) est vrai. |
Exemple
| Opérateurs | décrire | exemple |
|---|---|---|
| = | Simple et opérateur, attribuez la valeur de l'opérande à droite à l'opérande à gauche | C = A + B attribuera la valeur de A + B à C |
| + = | Ajouter et affecter l'opérateur, qui augmente l'opérande à droite à l'opérande à gauche et attribue le résultat à l'opérande à gauche | C + = a est égal à c = c + a |
| - = | L'opérateur de soustraction et d'affectation, qui soustrait l'opérande droit de l'opérande gauche et attribue le résultat à l'opérande gauche | C - = a est égal à c = c - a |
| * = | Multiplier et l'opérateur d'affectation, qui multiplie l'opérande droit avec la gauche et attribue le résultat à l'opérande gauche | C = a est égal à c = c a |
| / = | L'opérateur de division et d'affectation, qui divise l'opérande droit à gauche et attribue le résultat à l'opérande gauche | C / = a est égal à c = c / a |
| % = | Le coefficient et l'opérateur d'affectation exigent que le coefficient utilise deux opérandes et affecte le résultat à l'opérande à gauche. | C% = a est égal à c = c% a |
| << = | Opérateurs de quart de travail et de gauche | C << = 2 égaux C = C << 2 |
| >> = | Opérateurs de shift et d'affectation de droite | C >> = 2 égaux C = C >> 2 |
| & = | Opérateurs de bit et d'affectation | C & = 2 égaux C = C & 2 |
| ^ = | Les opérateurs de XOR et d'affectation bit | C ^ = 2 égaux C = C ^ 2 |
| | = | Opérateurs à bit ou affecter | C | = 2 égaux C = C | 2 |
Opérateur conditionnel (? :)
Les opérateurs conditionnels sont également appelés opérateurs ternaires. Cet opérateur se compose de trois opérandes et est utilisé pour évaluer les expressions mathématiques booléennes. Le but de cet opérateur est de déterminer quelles valeurs doivent être attribuées à la variable. Cet opérateur est écrit comme suit:
variable x = (expression)? valeur si vrai: valeur si faux
Voici un exemple:
classe publique test {public static void main (String args []) {int a, b; a = 10; b = (a == 1)? 20: 30; System.out.println ("La valeur de B est:" + b); b = (a == 10)? 20: 30; System.out.println ("La valeur de B est:" + b); }}Cela se traduira par ce qui suit:
La valeur de B est: 30 valeurs de b est: 20
Instance de symbole
Cet opérateur n'est utilisé que pour les variables de référence d'objet. Cet opérateur vérifie si un objet est un type unique (type ou type d'interface). L'opérateur d'instance est écrit comme:
(Variable de référence d'objet) instanceof (type de classe / interface)
Si l'objet à gauche de l'opérateur mentionné par la variable est le type ou le type d'interface à droite en passant IS-A Check, le résultat est vrai. Voici un exemple:
Classe publique Test {public static void main (String args []) {String name = "James"; // suivant sera rendu true car le nom est le type de chaîne booléenne result = name instanceof string; System.out.println (résultat); }}Cela produira les résultats suivants:
Copiez le code comme suit: vrai
Cet opérateur reviendra toujours à TRUE si l'objet comparé est une affectation compatible avec le bon type. Voici un autre exemple: Class Vehicle {} public class car étend le véhicule {public static void main (String args []) {véhicule a = new Car (); Résultat booléen = une instance de voiture; System.out.println (résultat); }}Cela produira les résultats suivants:
vrai
Priorité de l'opérateur Java
La priorité de l'opérateur détermine le regroupement des termes dans une expression. Cela affecte la façon dont une expression est évaluée. Un certain opérateur a une priorité plus élevée que les autres opérateurs; Par exemple: l'opérateur de multiplication a une priorité plus élevée que l'opérateur d'addition:
Par exemple, x = 7 + 3 2; Ici, x est attribué à 13, pas 20, car l'opérateur est une priorité plus élevée que l'opérateur +, il fonctionne donc d'abord la multiplication 3 * 2, puis ajoute 7.
Ici, les opérateurs avec la priorité la plus élevée sont au niveau le plus élevé de ce tableau, et ceux qui ont la priorité la plus faible apparaissent en bas. Dans une expression, plus l'opérateur de priorité est évalué en premier.
| gentil | Opérateurs | Pertinence |
|---|---|---|
| suffixe | () []. (opérateur de points) | De gauche à droite |
| Un dollar | ++ - -! ~ | De droite à gauche |
| Multiplication | * /% | De gauche à droite |
| Additif | + - | De gauche à droite |
| Changement | >> >>> << | De gauche à droite |
| Relation | >> = <<= | De gauche à droite |
| égal | ==! = | De gauche à droite |
| un peu et | & | De gauche à droite |
| Position extraordinaire ou | ^ | De gauche à droite |
| bit ou | | | De gauche à droite |
| Logique et | && | De gauche à droite |
| Logique ou | || | De gauche à droite |
| Conditionnel | ?: | De droite à gauche |
| Affectation | = + = - = * = / =% = >> = << = & = ^ == | De droite à gauche |
| virgule | , | De gauche à droite |