Conversion de type :

Tri de petit à grand, conversion de type automatique (conversion implicite)
Lorsqu'un petit type de données est utilisé sur un grand type de données, le résultat sera automatiquement converti en grand type
byte char short -->int -->long -->float -->double
Remarque : les byte char short ne sont pas convertis les uns aux autres. Ils participent aux opérations et sont d'abord convertis. en type int

Format : variable de type de données avec une grande plage = valeur de type de données avec une petite plage

Conversion de type forcée (conversion d'affichage)
Les données de type volumineux peuvent être converti si la perte de précision peut être tolérée Forcer la conversion en données de petit type
format : Type de données petite plage Variable = (Type de données petite plage) Type de données grande plage

Concept d'opérateur :

Pour les constantes Les symboles qui opèrent sur les variables sont appelés opérateurs

Le concept d'expression :

Utiliser des opérateurs pour connecter des constantes et une formule conforme à la grammaire Java peut être appelé une expression

Opérateurs couramment utilisés : opérateurs arithmétiques, opérateurs d'affectation, opérateurs relationnels, opérateurs logiques, opérateurs ternaires

opérateurs arithmétiques : + - * / % ++ --
en java Le résultat de l'opération de division entre deux données de type int est également int. Il suffit de couper le point décimal

Démonstration de code :
public static void main(String[] args) {

　int a = 10;
int b = 20;

System.out.println(a + b); // 30
System.out.println(a - b); 🎜 > System.out.println(a * b); // 200
System.out.println(a / b); // 0
System.out.println(1/2.0);
System.out.println(1/3);//0
System.out.println(2/3);//0
System.out.println("====== = ====================");
// Lorsqu'un + est utilisé entre une chaîne et un nombre, il indique un lien et in fine une nouvelle chaîne est obtenu
int d = 10;
　System.out.println("Heyhey"+10);//Heyhey 10
　System.out.println("Heyhey"+10+10);// Salut 1010
System.out.println("Heyhey"+(10+10));//Heyhey 20
System.out.println(10+10+"Heyhey");//20Heyhey

System .out.println("===========================");
System.out.println(10 %3); // Trouver le reste (modulo)
　System.out.println(7%2);// 1
　System.out.println("=========== === =========");
// 'a' ---> 97 'b'---> 98
// 'A' -- -> 65
// '0'---> 48
System.out.println('a' + 10);// 107
System.out.println(' A' + 10);// 75
System.out.println('0' + 10);// 58
System.out.println((char)('a' + 1));/ /b

}

Opérateur ++ :

Lorsque l'opérateur ++ est utilisé seul, que le symbole ++ soit à gauche ou à droite de la variable, cela signifie incrémenter la variable de 1

Quand + Lorsque l'opérateur + est utilisé ensemble, si le symbole ++ est sur le côté gauche de la variable, l'accent est mis sur sa modification d'abord (en l'incrémentant de 1) puis sur sa correspondance it,
; s'il se trouve sur le côté droit de la variable, il met d'abord l'accent sur sa correspondance, puis sur sa modification (en l'incrémentant de 1)

-- opérateur :

Quand - est utilisé seul, qu'il soit à gauche ou à droite d'une variable, cela signifie décrémenter la variable de 1
Quand -- est utilisé en combinaison, si -- est sur le côté gauche de la variable, l'accent est mis sur la modification (décrémentation de 1) d'abord puis sur la correspondance,
if Sur le côté droit de la variable, insistez d'abord sur la correspondance puis changement (diminution de 1)
Démonstration de code :public
static void main(String[] args) {

int b = 10;

System.out.println(b++);//10
System.out.println(b);//11
"============== ====");
int c = 20;
System.out.println(--c);// 19
System.out.println(c);// 19

int d = 30;
System.out.println(d--);//30
System.out.println(d );// 29
}

Opérateur d'affectation :

Opérateur d'affectation de base :=
Opérateur d'affectation étendu :+= -= *= /= %=
Modifier la gauche et le résultat sur la droite est assignée à la gauche
Remarque : la gauche ne peut pas être une constante
implique une conversion de type forcée
Avantages : plus efficace
Démonstration de code :
public static void main(String[] args) {

int a = 10;
a+=2; // a = a + (2) --- >
System.out.println(a); // 12

int b = 20
b-=2; // b = b - (2) --->ｂ　＝１８
　System.out.println(b);//18

　short c = 10;
　　//c = (short)(c + 10); ---> short = int
　c+=10;
　System.out.println(c);//20

}

Opérateurs relationnels :

==(égal) !=(différent) >(supérieur à) <(inférieur à) >=(supérieur ou égal à) <=(inférieur à ou égal à)
Les opérateurs relationnels sont tous de type booléen, vrai ou faux
Démonstration de code :
public static void main(String[] args) {
// TODO Stub de méthode généré automatiquement
int a = 10;
int b = 20;
int c = 10;

System.out.println( a == b);// false
System.out .println( a == c);// true
System.out.println("=====================");
System.out.println( a != b);// true
　System.out.println( a != c);// false
　System.out.println("======= ==== ===========");
System.out.println( a >= b);// false
System.out.println( a >= c);/ / true
　System.out.println("======================");
　System.out.println( a <= b);// true
　System.out.println( a <= c);// true 　
　System.out.println("=========== ===== =======");
System.out.println( a > b); // false
System.out.println( a > c); // false
System .out.println("======================");
System.out.println( a < b) ;// true
System.out.println( a < c);// false
System.out.println("=================== ====" );

}

Opérateurs logiques :

Les opérateurs logiques sont utilisés pour relier les expressions booléennes et le résultat final la valeur est booléenne
ne peut pas être écrite comme 3 ou : | Règles de fonctionnement : Si l'un des deux côtés est vrai, le résultat de l'ensemble. l'expression est vraie. Seulement si les deux côtés sont faux en même temps, le résultat est faux
Non : ! c'est faux, s'ils sont différents, c'est vrai
Démonstration de code :
public static void main(String[] args) {

System .out.println(true & true ); / T

System.out.println(false & true );// F

System.out.println(true & false );// F
System.out.println(false & false ); // F
System.out.println("=========================" );
System.out.println( true | true ); // T
System.out.println(false | true ); // T
System.out.println(true | false ); (false | false );// F
　System.out.println("==================== =====");
System.out.println(!true);// F
System.out.println(!false);// T
System.out.println(" =========== ==============");
System.out.println(true ^ true ); // F
System.out.println(false ^ true );// T
　System.out.println(true ^ false );// T
　System.out.println(false ^ false );// F

}

Court- circuit et : &&
Court-circuit et : ||
Avantage : efficacité supérieure
Court-circuit et : &&
Les règles de fonctionnement de base sont similaires à &, la différence est que, Si la gauche côté est faux, le côté droit n'est pas exécuté, et le résultat faux est directement renvoyé
ou : || >Expression ternaire :
Expression 1 : Résultat 2

Processus d'exécution :
Calculez d'abord le résultat de l'expression 1
Si le résultat est vrai, renvoyez le résultat 1, Sinon, renvoyez le résultat 2
Démonstration de code : (Obtenez le plus grand des deux nombres. )
(int x=3,y=4,z;z = (x>y)?x:y;//La variable z stocke le grand nombre des deux nombres.)
classe publique Demo09Operator {
public static void main(String[] args) {
　　int a = 10;
　　int b = 20;
　　int c = (a > b) ? System.out.println("c:" + c);
　}
}

(Comparez si deux données sont identiques)
public class Demo10Operator {
public static void main(String[] args) {
// Définir deux variables de type int
　　int a = 10;
　　int b = 20;

　　drapeau booléen = (a == b) ? true : false;
　　 // drapeau booléen = (a == b);
　　Système. out.println(flag);
}
}

(Obtenir la valeur maximale parmi trois entiers)
public class Demo11Operator {
public static void main(String[] args ) {
// Définissez trois variables de type int
　　int a = 10;
　　int b = 30;
　　int c = 20;

// Comparez les deux premières grandes valeurs de entier
int temp = ((a > b) ? a : b);
int max = ((temp > c) ? temp : c);
System.out.println ("max :" + max);
　}

}

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!