🧇运算符

算术运算符

image.png

+

在Java中+号的含义：

  1. 加减乘除的加
  2. 正负的正
  3. 连接符什么时候+号是作为连接符的呢？

任意数据类型的数据与字符串相连接的时候，那个+号就是连接符

-*/

整数除以整数得到的还是整数

  1. 举例子
  2. int i = 5;
  3. int j = 2;
  4. int a = i / j;
  5. System.out.println(a);//得2

%:模，取余

  1. 举例子：
  2. int i = 2;
  3. int j = 3;
  4. System.out.println(i % j); //1
  6. int a = 4;
  7. int b = 2;
  8. System.out.println(a % b); //0

++

  • 单独使用：

    1.   int i = 1;
    2.   //i++; // i = i + 1
    3.   ++i;
    4.   System.out.println(i);//2
    6.   不管++在前还是在后，结果都是一样,因为++都参与了运算

  • 参与运算：

    • ++在前：先自身加1，然后再参与运算

      1. int i = 1;
      2. int j = ++i;
      3. System.out.println(j);//2
      4. System.out.println(i);//2

    • ++在后：先参与运算，然后再自身加1

      1. int i = 1;
      2. int j = i++;
      3. System.out.println(j);//1
      4. System.out.println(i);//2
      1. 面试题：
      2. byte b1 = 1;
      3. b1 = b1 + 1;
      4. System.out.println(b1);//编译报错
      5. //针对byte类型和short类型的时候，只要右边有一个是变量，就会编译报错
      7. byte b1 = 1;
      8. b1++; //b1 = (byte)(b1 + 1)
      9. System.out.println(b1);//正确，因为++里面自带强制类型转换

—

  • 单独使用：

    1.   int i = 2;
    2.          //i--; // i = i - 1
    3.   --i;
    4.   System.out.println(i);//1
    6.   不管--在前还是在后，结果都是一样

  • 参与运算： ```java —在前：先自身减1，然后再参与运算 int i = 2; int j = —i; System.out.println(j);//1 System.out.println(i);//1

—在后：先参与运算，然后再自身减1 int i = 2; int j = i—; System.out.println(j);//2 System.out.println(i);//1

  1. ```
  2. 练习题：
  3.         int i = 10;
  4.         int j = i++ + ++i + i-- + --i;
  5.         System.out.println(j); //44

赋值运算符

=

  1. int i = 1;

+=

  1. int i = 1;
  2. i += 2;
  3. System.out.println(i); //3

-=
*=
/=
%=
注意：都自带了强制类型转换

关系运算符

关系运算符得出来的结果一定是boolean类型的数据，也就是说要么是true，要么是false

image.png


<
>=
<=
!=
==：比较两边的数据是否相等

  1. int i = 1;
  2. int j = 2;
  3. System.out.println(i == j);//false

==和=的区别？
=是赋值
==是比较

逻辑运算符

左右两边的数据的数据类型都是boolean类型，结果都是boolean类型

image.png

  1. &(单与)：
  2.     System.out.println(true & true);//true
  3.     System.out.println(true & false);//false
  4.     System.out.println(false & false);//false
  5.     System.out.println(false & true);//false
  7. 结论：两边只要有一个是false，结果就为false
  1. |(单或):
  2.     System.out.println(true | true); //true
  3.     System.out.println(true | false); //true
  4.     System.out.println(false | false); //false
  5.     System.out.println(false | true); //true
  7. 结论：两边只要有一个是true，结果就为true
  1. ^(异或)：
  2.     System.out.println(true ^ true); //false
  3.     System.out.println(true ^ false); //true
  4.     System.out.println(false ^ false); //false
  5.     System.out.println(false ^ true); //true
  7. 结论：两边相同为false，两边不同为true
  1. !(非)：
  2.     System.out.println(!true); //false
  3.     System.out.println(!false); //true
  4.     System.out.println(!!true); //true
  5.     System.out.println(!!!true); //false
  1. &&(双与)：
  2.     System.out.println(true && true);//true
  3.     System.out.println(true && false);//false
  4.     System.out.println(false && false);//false
  5.     System.out.println(false && true);//false
  7. 结论：两边只要有一个是false，结果就为false
  1. ||(双或)：
  2.     System.out.println(true || true); //true
  3.     System.out.println(true || false); //true
  4.     System.out.println(false || false); //false
  5.     System.out.println(false || true); //true
  7. 结论：两边只要有一个是true，结果就为true

&和&&的区别？
&&：如果左边为false，右边就不再执行了，结果就为false
&：如果左边为false，右边依然会执行，结果就为false

|和||的区别？
||：如果左边为true，右边就不再执行了，结果就为true
|：如果左边为true，右边依然会执行，结果就为true

总结：推荐使用&&和||，提高了执行效率

位运算符

两边的数据都是数字，结果也为数字

image.png
image.png

&(与位运算)

  1. System.out.println(3 & 2); //2

计算机怎么算的？
image.png

|(或位运算)

  1. System.out.println(3 | 2); //3

image.png

^(异或位运算)

  1. System.out.println(3 ^ 2); //1
  1. 练习？
  2.     int i = 1;
  3.     int j = 2;
  4. 通过某些方式，实现i和j变量的数据的调换？
  6. 方式一：
  7.   int temp = i;
  8.   i = j;
  9.   j = temp;
  11. 方式二：
  12.   i = i ^ j;
  13.   j = i ^ j;
  14.   i = i ^ j;

~(按位取反)

image.png
注意：符号位都会取反。

>>(右移位运算)

image.pngimage.png

  1. system.out.printIn(3 >> 2);
  2. A >> N --> A/2^N

<<(左移位运算)image.png

  1. System.out.printIn(3 << 2);
  2. A << N --> A*2^N //效率高，直接操作二进制

>>>(无符号右移)

  1. System.out.printIn(3 >> 2); //0

>>和>>>的区别是什么？

  • ：如果数据是负数，最左边的符号位是1，右移之后，左边要补1；

    • 如果数据是正数，最左边的符号位是0，右移之后，左边要补0；

  • ：不管数据是正数还是负数，右移之后，左边都要补0.

三元运算符(条件运算符，三目运算符)

  • 格式：条件表达式 ? 表达式1 : 表达式2;
  • 注意：条件表达式的结果一定是boolean类型
  • 执行流程：

如果条件表达式为true，就会执行表达式1，不会执行表达式2
如果条件表达式为false，就会执行表达式2，不会执行表达式1

练习：

  1. 获取两个数的较大值？
  2.     int i = 2;
  3.     int j = 3;
  5.     int max = i > j ? i : j;
  6.     System.out.println(max); //得3
  • 注意事项：
  1. 三元运算符是一个运算符，既然是运算符，就一定会有一个结果，所以呢，

表达式1和表达式2都会得到一个结果，所以表达式1和表达式2中不能是输出语句

  1. 3 > 2 ? System.out.println("在吗") : System.out.println("约吗");//格式错误
  1. 表达式1和表达式2既然会得到一个结果，如果传递给一个变量去接收，该变量的数据类型应该和表达式1和表达式2的结果的数据类型匹配 ```java int i = 3 > 2 ? 1 : 2; boolean b = 3 > 2 ? true : false; double d = 3 > 2 ? 1.1 : 2.2;

double d = 3 > 2 ? 1 : 2; int c = 3 > 2 ? ‘a’ : ‘b’;//97 都可以

  2. <a name="uyilz"></a>
  3. # 🐶键盘录入
  5. 键盘录入的实现步骤？<br />第一步：导包
  6. ```java
  7. import java.util.Scanner;

注意：写在class的上面，package的下面

第二步：创建对象

  1. Scanner sc = new Scanner(System.in);

第三步：调用方法

  1. int i = sc.nextInt();//接收录入的数字
  2. String s = sc.next();//接收录入的字符串

整体;

  1. public class Test02 {
  2.     public static void main(String[] args) {
  3.         Scanner sc = new Scanner(System.in);
  5.         System.out.println("请输入第一个数字");
  6.         int i = sc.nextInt();
  8.         System.out.println("请输入第二个数字");
  9.         int j = sc.nextInt();
  11.         System.out.println(i + "..." +j);
  12.     }
  13. }

📽if语句

格式一

  1. if(条件表达式) {
  2.             语句体;
  3.         }

条件表达式最终的结果只能是boolean类型，要么是true，要么是false

执行流程：
如果程序执行到if语句的时候，会去看条件表达式的结果是true还是false,
如果是true，就会进入到if中，执行里面的语句体内容，
如果是false，就不会进入到if中，就不会执行到里面的语句体内容。

例子：

  1. int i = 1;
  2. if(i > 2) {
  3.     System.out.println("约吗");
  4. }
  5. System.out.println("滚犊子");

if语句常见的考试题？

  1. 第一题：
  2.     boolean b = true;
  3.     if(b == false) {
  4.         System.out.println("在吗");
  5.     }
  6.     System.out.println("约吗");
  8. 第二题：
  9.     boolean b = true;
  10.     if(b = false) {
  11.            System.out.println("在吗");
  12.     }
  13.     System.out.println("约吗");
  15. 第三题：
  16.     boolean b = false;
  17.     if(b); {
  18.         System.out.println("在吗");
  19.     }
  20.     System.out.println("约吗");
  22. 1.由一对花括号括起来的东西，称为代码块
  23.     {
  24.         代码
  25.     }
  26. 2.在程序中，分号可以随意写
  27. 3.当if语句中的语句体内容，只有一条有效语句的时候，花括号是可以省略不写的
  29. 第四题：
  30.     boolean b = false;
  31.     if(b)
  32.            System.out.println("在吗");
  34.     System.out.println("约吗");
  35.     //输出约吗
  37. 第五题：
  38.     boolean b = false;
  39.     if(b)
  40.         int i = 1;//这个不是有效语句
  41.         System.out.println("在吗");//编译报错

格式二

  1. if(条件表达式) {
  2.     语句体;
  3. } else {
  4.     语句体;
  5. }

执行流程：
如果程序执行到if语句的时候，会去看条件表达式的结果是true还是false,
如果是true，就会进入到if中，执行里面的语句体内容，
如果是false，就不会进入到if中，会进入到else中，执行里面的语句体

  1. 练习：
  2. 获取两个数的较大值？
  3.     int i = 1;
  4.     int j = 2;
  6.     if(i > j) {
  7.         System.out.println(i + "最大");
  8.     } else {
  9.         System.out.println(j + "最大");
  10.     }

if语句的第二种格式可以和三元运算符互换
三元运算符代码写的少一些，if语句的第二种格式可读性更高一些

格式三

  1. if(条件表达式) {
  2.     语句体;
  3. } else if(条件表达式) {
  4.     语句体;
  5. } else if(条件表达式) {
  6.     语句体;
  7. } ...
  8. else {
  9.     语句体;
  10. }

执行流程：
如果程序执行到if语句的时候，会去看条件表达式的结果是true还是false,
如果为true，就会执行if中的语句体内容，其他的语句体不会执行
如果为false，就会继续向下走，看else if的条件表达式的结果是true还是false,
如果是true，就进入到elseif中，执行里面的语句体内容
如果是false，就继续向下走……
如果if和所有的elseif中的条件表达式都为false，就会执行else中的语句体内容

  1. 练习：
  2. int i = 5;
  3. if(i > 7) {
  4.     System.out.println("哈哈");
  5. } else if(i > 6) {
  6.     System.out.println("呵呵");
  7. } else if(i > 5) {
  8.     System.out.println("嘿嘿");
  9. } else {
  10.     System.out.println("嘻嘻");
  11. }
  12. 注意：else可以省略不写
  14. int i = 6;
  15. if(i > 7) {
  16.     System.out.println("哈哈");
  17. } else if(i > 6) {
  18.     System.out.println("呵呵");
  19. } else if(i > 5) {
  20.     System.out.println("嘿嘿");
  21. }
  1. 考试题？
  2. int a;
  3. int i = 6;
  4. if(i > 7) {
  5.     a = 1;
  6. } else if(i > 6) {
  7.     a = 2;
  8. } else if(i > 5) {
  9.     a = 3;
  10. } /* else {
  11. }*/
  12. System.out.println(a);//编译报错 3

🐝Switch语句

  1. 格式：
  2. switch(表达式) {
  3.     case 取值1:
  4.         语句体;
  5.         break;
  6.        case 取值2:
  7.         语句体;
  8.         break;
  9.     ... ...
  10.     default:
  11.         语句体;
  12.         break;
  13. }

执行流程：
当程序执行到switch的时候，会进入到switch，会找第一个case进行匹配，如果匹配成功，就进入到case中执行
里面的语句体内容和break。如果没有匹配成功，会继续向下走，找第二个case继续匹配… …
如果所有的case都不匹配，最后会执行default中的语句体内容。

  1. 练习：
  2. int i = 3;
  3. switch(i) {
  4.     case 1:
  5.         System.out.println("哈哈");
  6.         break;
  7.     case 2:
  8.         System.out.println("呵呵");
  9.         break;
  10.     case 3:
  11.         System.out.println("嘻嘻");
  12.         break;
  13.     default:
  14.         System.out.println("嘿嘿");
  15.         break;
  16. }

我们在使用switch的时候需要注意哪些问题？

  1. switch中的表达式的数据的数据类型可以为哪些？

byte,short,int,char,String,枚举

  1. default可以放在任意一行，但是不管放在那一行，都会先找第一个case去匹配，如果所有的case都不匹配，才会执行default

default可以省略不写，但建议写上

  1. break是结束语句，可以不写，就容易造成switch的穿透现象

如果匹配过一次或者执行过default之后，都不会再进行二次匹配了，但是语句体内容该执行还是会执行

  1. switch结束标记：

a.break
b.遇到结尾}

什么时候使用switch，什么时候使用if？
如果是判断某个区间范围的话，推荐使用if
如果是判断某几个数据的话，推荐使用switch

🦉局部代码块

由一对花括号括起来的，就称为代码块

  1. {
  2.     代码
  3. }

什么是局部代码块？

写在main(程序执行的入口)里面的代码块，就称为局部代码块

  1. public static void main(String[] args) {
  2.     int j = 1;
  3.     {
  5.     }
  6. }

局部代码块有什么用呢？
能够让变量更早的在内存中消失，节省内存空间

  1. public static void main(String[] args) {
  2.     {
  3.         int j = 1;   
  4.     }
  5. }

🐞for循环

  1. 格式：
  2. for(初始化条件; 判断条件; 控制条件) {
  3.     语句体;
  4. }
  • 初始化条件：定义一个变量，并且赋值
  • 判断条件：关系运算符
  • 控制条件：自增+1
  • 语句体：想要重复执行的内容代码

执行流程：
初始化条件 —> 判断条件 —> 语句体 —> 控制条件
—> 判断条件 —> 语句体 —> 控制条件
—> 判断条件 —> 语句体 —> 控制条件
… …
直到判断条件不满足，循环结束

练习：
需求：在控制台上打印出10个1

  1. 在学习循环之前：
  2.     System.out.println(1);
  3.     System.out.println(1);
  4.     System.out.println(1);
  5.     System.out.println(1);
  6.     System.out.println(1);
  7.     System.out.println(1);
  8.     System.out.println(1);
  9.     System.out.println(1);
  10.     System.out.println(1);
  11.     System.out.println(1);
  13. 在学习循环之后：
  14.     for(int i = 1; i <= 10; i++) {
  15.         System.out.println(1);
  16.     }

需求：在控制台上打印出1-10的数字

  1. for(int i = 1; i <= 10; i++) {
  2.     System.out.println(i);
  3. }

需求：在控制台上打印出1-10的和(累加和思想)？

  1. 1+2+3+4+5+6+7+8+9+10
  3. int sum = 0;
  5. for(int i = 1; i <= 10; i++) {
  6.     sum = i + sum;
  7. }
  8. System.out.println(sum);

需求：在控制台上打印出1-100之间的偶数？

  1. 方式一：
  2. for(int i = 1; i <= 100; i++) {
  3.     //判断i是否为偶数
  4.     if(i % 2 == 0) {
  5.         System.out.println(i);
  6.     }
  7. }
  9. 方式二：
  10. for(int i = 1; i <= 100; i++) {
  11.     //判断i是否为偶数
  12.     if(i % 2 != 1) {
  13.         System.out.println(i);
  14.     }
  15. }
  17. 方式三：
  18. for(int i = 2; i <= 100; i+=2) {
  19.     System.out.println(i);
  20. }

需求：在控制台上打印出1-10之间奇数的个数？(统计思想)

  1. int count = 0;
  3. for(int i = 1; i <= 10; i++) {
  4.     if(i % 2 == 1) {
  5.         count++;
  6.     }
  7. }
  8. System.out.println(count);

🐣while循环

  1. 格式：
  2.     初始化条件;
  3.     while(判断条件) {
  4.         语句体;
  5.         控制条件;
  6.     }

执行流程：
初始化条件 —> 判断条件 —> 语句体 —> 控制条件
—> 判断条件 —> 语句体 —> 控制条件
—> 判断条件 —> 语句体 —> 控制条件
… …
直到判断条件不满足，循环结束

练习：
需求：在控制台上打印出10个1

  1. int i = 1;
  2. while(i <= 10) {
  3.     System.out.println(1);
  4.     i++;
  5. }

需求：在控制台上打印出1-10的数字

  1. int i = 1;
  2. while(i <= 10) {
  3.     System.out.println(i);
  4.     i++;
  5. }

需求：在控制台上打印出1-10的和(累加和思想)？

  1. int sum = 0;
  2. int i = 0;
  3. while(i <= 10) {
  4.     sum = sum + i;
  5.     //sum += i;
  6.     i++;
  7. }
  8. System.out.println(sum);

需求：在控制台上打印出1-10之间的偶数？

  1. int i = 1;
  2. while(i <= 10) {
  3.     //判断是否为偶数
  4.     if(i % 2 == 0) {
  5.         System.out.println(i);
  6.     }
  8.     i++;
  9. }

需求：在控制台上打印出1-10之间奇数的个数？(统计思想)

  1. int count = 0;
  2. int i = 1;
  3. while(i <= 10) {
  4.     if(i % 2 == 1) {
  5.         count++;
  6.     }
  7.     i++;
  8. }
  9. System.out.println(count);

🦇do…while循环

  1. 格式：
  2. 初始化条件;
  3. do {
  4.     语句体;
  5.     控制条件;
  6. } while(判断条件);

执行流程：
初始化条件 —> 语句体 —> 控制条件 —> 判断条件
—> 语句体 —> 控制条件 —> 判断条件
—> 语句体 —> 控制条件 —> 判断条件
… …
—> 语句体 —> 控制条件 —> 直到判断条件不满足的时候，循环结束

练习：
需求：在控制台上打印出1-10的数字

  1. int i = 1;
  2. do {
  3.     System.out.println(i);
  4.     i++;
  5. } while(i <= 10);

🐜while和for和do…while循环的区别

do…while 和 for和while

do…while：
语句体和控制条件至少会执行一次
语句体和控制条件和判断条件执行的次数是一样多的

for和while：
语句体和控制条件可以一次都不执行
语句体和控制条件比判断条件少执行一次

while和for

while：初始化条件在while循环结束之后，依然可以继续使用

  1. int i = 1;
  2. while(i <= 10) {
  4. }
  5. System.out.println(i);

for：初始化条件，一旦for循环结束，就用不了了

  1. for(int i = 1; i <= 10; i++) {
  3. }
  4. System.out.println(i);//编译报错，因为找不到变量i
  6. 变形写法：
  7. int i;
  8. for(i = 1; i <= 10; i++) {
  10. }
  11. System.out.println(i);

什么时候使用for循环？什么时候使用while循环？
明确循环次数建议使用for
不明确循环次数建议使用while

🙈死循环

最简单的两种死循环的写法：

  1. for(;;) {
  3. }
  1. *while(true) {
  3. }

死循环通常会结合break和continue使用。

🐽break和continue

  • break：

它可以使用在switch中，用来结束switch的
也可以使用在循环中，用来结束循环的(跳出循环)

  • continue：

它用在循环中，用来结束本次循环，继续下一次循环

  • 注意事项
    1. for(int i = 1; i <= 10; i++) {
    2.   if(i == 5) {
    3.       //break;
    4.       continue;
    5.       System.out.println("约吗");//编译报错
    6.   }
    7. }
    上面的程序是编译报错，为什么呢？
    因为System.out.println(“约吗”)永远都执行不到

在同一对花括号内，break和continue关键字的下面，不能有任何语句，因为永远都执行不到，会编译报错的

🐤循环嵌套

指将一个循环放入到另外一个循环的里面

需求：在控制台上打印出由组成的矩形


*

版本一：

  1. System.out.println("****");
  2. System.out.println("****");
  3. System.out.println("****");
  4. System.out.println("****");

版本二：

  1. for(int i = 1; i <= 4; i++) {
  2.     System.out.println("****");
  3. }

版本三：

  1. for(int i = 1; i <= 4; i++) {
  2.     for(int j = 1; j <= 4; j++) {
  3.         System.out.print("*");
  4.     }
  5.     System.out.println();//加In是为了换行
  6. }

需求：在控制台上打印出由组成的三角形


*

*

版本一：

  1. System.out.println("*");
  2. System.out.println("**");
  3. System.out.println("***");
  4. System.out.println("****");
  5. System.out.println("*****");

版本二：

  1. for(int i = 1; i <= 5; i++) {
  2.     /*
  3.         外层循环第一次的时候，里面打印1个*
  4.         外层循环第二次的时候，里面打印2个*
  5.         外层循环第三次的时候，里面打印3个*
  6.         外层循环第四次的时候，里面打印4个*
  7.         外层循环第五次的时候，里面打印5个*
  8.     */
  10.     //System.out.println("*****");
  11.     for(int j = 1; j <= i; j++) {
  12.         System.out.print("*");
  13.     }
  14.     System.out.println();//换行
  15. }

记住：外层循环控制行数，内层循环控制列数