[Notes Java super invincibles et détaillées de Han Shunping] Du débutant au compétent --- cinq opérateurs

Enterprise 2023-09-16 20:38:49 views: null

1. Opérateurs arithmétiques

1. Introduction

Les opérateurs arithmétiques opèrent sur des variables de type numérique.

 2. Démontrer l'utilisation des opérateurs arithmétiques

public class ArithmeticOperator {
//编写一个 main 方法
public static void main(String[] args) {
// /使用
System.out.println(10 / 4); //从数学来看是 2.5, java 中 2
System.out.println(10.0 / 4); //java 是 2.5
// 注释快捷键 ctrl + /, 再次输入 ctrl + / 取消注释
double d = 10 / 4;//java 中 10 / 4 = 2, 2=>2.0
System.out.println(d);// 是 2.0
    }
}

% prend le modulo et le reste
 est dans l'essence de %. Regardez une formule !!!! a % b = a - a / b * b

public class ArithmeticOperator {
//编写一个 main 方法
public static void main(String[] args) {// % 取模 ,取余
// 在 % 的本质 看一个公式!!!! a % b = a - a / b * b
// -10 % 3 => -10 - (-10) / 3 * 3 = -10 + 9 = -1
// 10 % -3 = 10 - 10 / (-3) * (-3) = 10 - 9 = 1
// -10 % -3 = (-10) - (-10) / (-3) * (-3) = -10 + 9 = -1
System.out.println(10 % 3); //1
System.out.println(-10 % 3); // -1
System.out.println(10 % -3); //1
System.out.println(-10 % -3);//-1
    }
}
Utilisation de ++ 
int i = 10;
i++;//自增 等价于 i = i + 1; => i = 11
++i;//自增 等价于 i = i + 1; => i = 12
System.out.println("i=" + i);//12
Utiliser comme expression
Avant ++ : ++i est d'abord incrémenté puis attribué.
Après ++ : i++ attribue d'abord une valeur puis incrémente. 
int j = 8;
//int k = ++j; //等价 j=j+1;k=j;
int k = j++; // 等价 k =j;j=j+1;
System.out.println("k=" + k + "j=" + j);//8 9

 6Exercices en classe auto-croissants et auto-décroissants

public class ArithmeticOperatorExercise01 {
//编写一个 main 方法
public static void main(String[] args) {
// int i = 1;//i->1
// i = i++; //规则使用临时变量: (1) temp=i;(2) i=i+1;(3)i=temp;
// System.out.println(i); // 1
// int i=1;
// i=++i; //规则使用临时变量: (1) i=i+1;(2) temp=i;(3)i=temp;
// System.out.println(i); //2
//
// 测试输出
int i1 = 10;
int i2 = 20;
int i = i1++;
System.out.print("i="+i);//10
System.out.println("i2="+i2);//20
i = --i2;
System.out.print("i="+i);//19
System.out.println("i2="+i2);//19
}
}
1) S'il reste encore 59 jours de vacances, demandez : Total xx semaines et xx jours
2) Définissez une variable pour stocker la température Fahrenheit. La formule pour convertir la température Fahrenheit en température Celsius est : 5/9* ( température Fahrenheit -100). Demandez la température Celsius correspondant à la température Fahrenheit. [234.5] 
public class ArithmeticOperatorExercise02 {
//编写一个 main 方法
public static void main(String[] args) {
//1.需求:
//假如还有 59 天放假，问：合 xx 个星期零 xx 天
//2.思路分析
//(1) 使用 int 变量 days 保存 天数
//(2) 一个星期是 7 天 星期数 weeks： days / 7 零 xx 天 leftDays days % 7
//(3) 输出
//3.走代码
int days = 25911;
int weeks = days / 7;
int leftDays = days % 7;
System.out.println(days + "天 合" + weeks + "星期零" + leftDays + "天");
//1.需求
//定义一个变量保存华氏温度，华氏温度转换摄氏温度的公式为
//：5/9*(华氏温度-100),请求出华氏温度对应的摄氏温度
//
//2 思路分析
//(1) 先定义一个 double huaShi 变量保存 华氏温度
//(2) 根据给出的公式，进行计算即可 5/9*(华氏温度-100)
// 考虑数学公式和 java 语言的特性
//(3) 将得到的结果保存到 double sheShi
//3 走代码
double huaShi = 1234.6;
double sheShi = 5.0 / 9 * (huaShi - 100);
System.out.println("华氏温度" + huaShi
+ " 对应的摄氏温度=" + sheShi);
}
}

2. Opérateurs relationnels

1. Introduction

  • Les résultats des opérateurs relationnels sont tous booléens , c'est-à-dire qu'ils sont vrais ou faux.
  • Les expressions relationnelles sont souvent utilisées dans les conditions des structures if ou dans les conditions des structures en boucle.
2. 

//演示关系运算符的使用
//
public class RelationalOperator {
//编写一个 main 方法
public static void main(String[] args) {
int a = 9; //老韩提示: 开发中，不可以使用 a, b
int b = 8;
System.out.println(a > b); //T
System.out.println(a >= b); //T
System.out.println(a <= b); //F
System.out.println(a < b);//F
System.out.println(a == b); //F
System.out.println(a != b); //T
boolean flag = a > b; //T
System.out.println("flag=" + flag);
}
}

3.Détails

  • Les résultats des opérateurs relationnels sont tous booléens , c'est-à-dire qu'ils sont vrais ou faux .
  • Les expressions composées d'opérateurs relationnels sont appelées expressions relationnelles. une > b
  • L'opérateur de comparaison "==" ne peut pas être écrit par erreur comme "="

3. Opérateurs logiques

1. Introduction
Utilisé pour connecter plusieurs conditions (plusieurs expressions relationnelles), le résultat final est également une valeur booléenne .
2. Liste des opérateurs logiques
Étudier en deux groupes
1) Court-circuit avec && , court-circuit ou || , négation !
2) ET logique & , OU logique | , ^ XOR logique

Expliquez les règles de fonctionnement logique :
  1. a&b : & est appelé ET logique : règle : quand a et b sont vrais en même temps, le résultat est vrai, sinon il est faux
  2. a&&b : && s'appelle court-circuit ET : règle : quand a et b sont vrais en même temps, le résultat est vrai, sinon il est faux
  3. a|b : | Appelé OU logique, règle : lorsque l'un de a et b est vrai, le résultat est vrai, sinon il est faux
  4. a||b : || est appelé OU de court-circuit, règle : quand l'un de a et b est vrai, le résultat est vrai, sinon il est faux
  5. !a : Appelée négation, ou non opération. Quand a est vrai, le résultat est faux ; quand a est faux , le résultat est vrai
  6. a^b : appelé OU exclusif logique. Lorsque a et b sont différents, le résultat est vrai, sinon il est faux.

1. Règles de base de && et &

nom grammaire Caractéristiques
Court-circuit et &&
Conditions  1 et  Conditions 2
Si les deux conditions sont vraies , le résultat est vrai, sinon faux
ET logique &
Conditions 1 et Conditions 2
Si les deux conditions sont vraies , le résultat est vrai, sinon faux
1.1. La différence entre l'utilisation de && et &
  • && court-circuit AND : Si la première condition est false , la deuxième condition ne sera pas jugée et le résultat final est false , ce qui est très efficace.
  • & ET logique : que la première condition soit fausse ou non , la deuxième condition doit être jugée
/**
* 演示逻辑运算符的使用
*/
    public class LogicOperator01 {
    //编写一个 main 方法
        public static void main(String[] args) {
        //&&短路与 和 & 案例演示
            int age = 50;
            if(age > 20 && age < 90) {
                System.out.println("ok100");
}
//&逻辑与使用
            if(age > 20 & age < 90) {
                System.out.println("ok200");
}
//区别
        int a = 4;
        int b = 9;
//对于&&短路与而言，如果第一个条件为 false ,后面的条件不再判断
//对于&逻辑与而言，如果第一个条件为 false ,后面的条件仍然会判断
            if(a < 1 & ++b < 50) {
                System.out.println("ok300");
}
                System.out.println("a=" + a + " b=" + b);// 4 10
}
}

2. Règles de base pour || et |
nom grammaire Caractéristiques
Court-circuit ou ||
Condition 1|| Condition 2
Tant que l’une des deux conditions est vraie, le résultat est vrai, sinon il est faux.
| logique ou
Condition 1 | Condition 2
Tant qu'une condition est vraie, le résultat est vrai, sinon il est faux

2.1 La différence entre .|| et |

  •  || Court-circuit ou : Si la première condition est vraie , la deuxième condition ne sera pas jugée et le résultat final est vrai , ce qui est très efficace.
  •  | OU logique : que la première condition soit vraie ou non , la deuxième condition doit être jugée, ce qui est inefficace
  •  Pendant le développement, nous utilisons essentiellement ||

3. Rébellion

nom grammaire Caractéristiques
! Non (négation)
Etat _
Si la condition elle-même est vraie, le résultat est faux , sinon il est vrai 
public class InverseOperator {
//编写一个 main 方法
    public static void main(String[] args) {
    //! 操作是取反 T->F , F -> T
        System.out.println(60 > 20); //T
        System.out.println(!(60 > 20)); //F
    }
}

4. XOR logique

a^b : appelé OU exclusif logique. Lorsque a et b sont différents, le résultat est vrai, sinon il est faux.
^ XOR logique, System.out.println( (4 < 1) ^ (6 > 3) ); // T 
public class InverseOperator {
//编写一个 main 方法
    public static void main(String[] args) {
        //a^b: 叫逻辑异或，当 a 和 b 不同时，则结果为 true, 否则为 false
        boolean b = (10 > 1) ^ ( 3 > 5);
        System.out.println("b=" + b);//T
    }
}

(Supplémentaire) if déclaration :

Le format de base de l'instruction if est le suivant :

if (条件) {
    // 条件为真时执行的代码块
}

Une condition peut être n'importe quelle expression qui renvoie une valeur booléenne (vrai ou faux). Si la condition est vraie, le bloc de code dans l'instruction if sera exécuté. Si la condition est fausse, le bloc de code sera ignoré.

Vous pouvez également ajouter une clause else après l'instruction if, comme indiqué ci-dessous :

if (条件) {
    // 条件为真时执行的代码块
} else {
    // 条件为假时执行的代码块
}

Dans ce cas, si la condition est vraie, le bloc de code de l'instruction if sera exécuté ; si la condition est fausse, le bloc de code de l'instruction else sera exécuté.

4. Opérateur d'affectation

1 Introduction
L'opérateur d'affectation attribue la valeur après une certaine opération à la variable spécifiée.
2 Classification des opérateurs d'affectation
  •  Opérateur d'affectation de base =
        entier a = 10 ;
  •  opérateur d'affectation composé
        +=, -= , *= , /= , %=, etc. , concentrez-vous sur un += , les autres utilisations sont les mêmes.
une += b ; [ 等了 a = a + b; ]
une -= b ; [ 等了 a = a - b; ]
3 Caractéristiques des opérateurs d'affectation
  •  L'ordre des opérations est de droite à gauche : i nt num = a + b + c;
  •  Le côté gauche de l'opérateur d'affectation ne peut être que des variables , et le côté droit peut être des variables, des expressions et des valeurs constantes : int num = 20 ; int num2= 78 * 34 - 10 ; int num3 = a;
  • L'opérateur d'affectation composé est équivalent à l'effet suivant : a+=3 ; équivalent à a=a+3 ; et ainsi de suite.
  •  Les opérateurs d'affectation composée effectuent des conversions de type. : octet b = 2; b+=3; b++;
    //演示赋值运算符的使用
public class AssignOperator {
    //编写一个 main 方法
    public static void main(String[] args) {
        int n1 = 10;
        n1 += 4;// n1 = n1 + 4;
    System.out.println(n1); // 14
        n1 /= 3;// n1 = n1 / 3;//4
    System.out.println(n1); // 4
        //复合赋值运算符会进行类型转换
        byte b = 3;
        b += 2; // 等价 b = (byte)(b + 2);
        b++; // b = (byte)(b+1);
    }
}

5. Opérateur ternaire

1Grammaire de base
Expression conditionnelle ? expression1 : expression2 ;
Règles de fonctionnement :
1. Si l'expression conditionnelle est vraie , le résultat après l'opération est l'expression 1 ;
2. Si l'expression conditionnelle est false , le résultat après l'opération est expression 2 ;
Formule : [ Maître Yideng : Maître Yizhen ] 
//三元运算符使用
    public class TernaryOperator {
//编写一个 main 方法
    public static void main(String[] args) {
        int a = 10;
        int b = 99;
// 解读
// 1. a > b 为 false
// 2. 返回 b--, 先返回 b 的值,然后在 b-1
// 3. 返回的结果是 99
        int result = a > b ? a++ : b--;
            System.out.println("result=" + result);
            System.out.println("a=" + a);
            System.out.println("b=" + b);
    }
}
2Détails d'utilisationTernaryOperatorDetail.java _
1) L'expression 1 et l'expression 2 doivent être d'un type pouvant être affecté à la variable de réception ( ou pouvant être automatiquement converti )
2) L'opérateur ternaire peut être converti en une instruction if--else 
//三元运算符细节
    public class TernaryOperatorDetail {
//编写一个 main 方法
    public static void main(String[] args) {
//表达式 1 和表达式 2 要为可以赋给接收变量的类型
//(或可以自动转换/或者强制转换)
    int a = 3;
    int b = 8;
    int c = a > b ? (int)1.1 : (int)3.4;//可以的
        double d = a > b ? a : b + 3;//可以的，满足 int -> double
    }
}
public class TernaryOperatorExercise {
//编写一个 main 方法
public static void main(String[] args) {
//案例：实现三个数的最大值
int n1 = 553;
int n2 = 33;
int n3 = 123;
//思路
//1. 先得到 n1 和 n2 中最大数 , 保存到 max1
//2. 然后再 求出 max1 和 n3 中的最大数，保存到 max2
int max1 = n1 > n2 ? n1 : n2;
int max2 = max1 > n3 ? max1 : n3;
System.out.println("最大数=" + max2);
//使用一条语句实现, 推荐使用上面方法
//老师提示: 后面我们可以使用更好方法,比如排序
// int max = (n1 > n2 ? n1 : n2) > n3 ?
// (n1 > n2 ? n1 : n2) : n3;
// System.out.println("最大数=" + max);
//
int abcclass = 10;
int n = 40;
int N = 50;
System.out.println("n=" + n);//40
System.out.println("N=" + N);//50
//? abc 和 aBc 是两个不同变量
int abc = 100;
int aBc = 200;
//int a b = 300;
//int a-b=10;
int goto1 = 10;
}
}

6. Priorité des opérateurs

1) Les opérateurs ont des priorités différentes. La soi-disant priorité est l'ordre des opérations dans les opérations d'expression. Comme le montre le tableau de droite, les opérateurs de la ligne précédente sont toujours prioritaires sur ceux de la ligne suivante.
2) Seuls les opérateurs unaires et les opérateurs d'affectation opèrent de droite à gauche.
3) Ne mémorisez pas la liste . Si vous l’utilisez davantage, vous vous y familiariserez.

 

Je suppose que tu aimes

Origine blog.csdn.net/qq_45206556/article/details/131789918
conseillé
Classement
du quotidien
Plus
2024-06-09(0)
2024-06-08(0)
2024-06-07(0)
2024-06-06(0)
2024-06-05(0)
2024-06-04(2)
2024-06-03(0)
2024-06-02(1)
2024-06-01(0)
2024-05-31(0)

Code World

© 2018 codetd.com